@digione/node-custom-api 0.0.1

package/models/user/organ.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserOrganAssociation = exports.UserOrganModel = exports.UserOrganAttr = void 0;
+const tslib_1 = require("tslib");
+const sequelize = require("sequelize");
+const db_1 = require("../../utils/db");
+const tax_1 = require("../system/tax");
+const user_1 = require("./user");
+const database_1 = require("../../database");
+exports.UserOrganAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false
+    },
+    created: {
+        type: sequelize.DATE,
+        allowNull: false,
+        defaultValue: sequelize.NOW
+    },
+    updated: sequelize.DATE,
+    ordering_count: sequelize.INTEGER({ length: 11 }),
+    created_by: sequelize.INTEGER({ length: 11 }),
+    contact_name: sequelize.STRING(255),
+    username: sequelize.STRING(255),
+    organ_phone: {
+        type: sequelize.STRING(255),
+        allowNull: false,
+        defaultValue: ""
+    },
+    organ_fax: {
+        type: sequelize.STRING(255),
+        allowNull: false,
+        defaultValue: ""
+    },
+    organ_email: {
+        type: sequelize.STRING(255),
+        allowNull: false,
+        defaultValue: ""
+    },
+    organ_name: {
+        type: sequelize.STRING
+    },
+    organ_website: {
+        type: sequelize.STRING
+    },
+    type: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false,
+        defaultValue: 1
+    },
+    tax_id: {
+        type: sequelize.STRING(255)
+    },
+    parent_id: sequelize.INTEGER({ length: 11 }),
+    vat_id: sequelize.INTEGER({ length: 11 }),
+    fee_id: sequelize.INTEGER({ length: 11 }),
+    status: sequelize.STRING({ length: 15 }),
+    setting: sequelize.JSON,
+    setting_user: sequelize.JSON
+};
+const UserOrganModel = database_1.default.define("UserOrgan", exports.UserOrganAttr, {
+    tableName: 'organs'
+});
+exports.UserOrganModel = UserOrganModel;
+const UserOrganAssociation = {
+    organ: {
+        model: UserOrganModel,
+        alias: "organ",
+        join: (ref, { attributes_all = false, attributes = undefined, required = false } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (attributes_all) {
+                attributes = yield (0, db_1.getFieldAll)(ref + '_' + UserOrganModel.getTableName());
+            }
+            return {
+                required,
+                attributes,
+                as: UserOrganAssociation.organ.alias,
+                model: UserOrganAssociation.organ.model.schema(ref, "_")
+            };
+        })
+    },
+    vat: {
+        model: tax_1.SystemTaxModel,
+        alias: "vat",
+        join: (ref, { attributes = undefined, required = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                required,
+                attributes,
+                model: UserOrganAssociation.vat.model.schema(ref, "_"),
+                as: UserOrganAssociation.vat.alias
+            };
+        })
+    }
+};
+exports.UserOrganAssociation = UserOrganAssociation;
+// organ
+user_1.UserModel.belongsTo(UserOrganAssociation.organ.model, { as: UserOrganAssociation.organ.alias, foreignKey: "organ_id" });
+// vat
+UserOrganModel.belongsTo(UserOrganAssociation.vat.model, { as: UserOrganAssociation.vat.alias, foreignKey: "vat_id", targetKey: "id" });

package/models/user/profile.d.ts

@@ -0,0 +1,31 @@
+import * as sequelize from "sequelize";
+export declare const UserProfileAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        allowNull: boolean;
+        autoIncrement: boolean;
+    };
+    created: {
+        type: sequelize.DateDataTypeConstructor;
+        allowNull: boolean;
+        defaultValue: sequelize.AbstractDataTypeConstructor;
+    };
+    updated: sequelize.DateDataTypeConstructor;
+    ordering_count: {
+        type: sequelize.IntegerDataType;
+        defaultValue: number;
+    };
+    created_by: {
+        type: sequelize.IntegerDataType;
+    };
+    user_id: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+    };
+    first_name: sequelize.StringDataType;
+    last_name: sequelize.StringDataType;
+    display_name: sequelize.StringDataType;
+};
+declare const UserProfileModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export { UserProfileModel };

package/models/user/profile.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserProfileModel = exports.UserProfileAttr = void 0;
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+exports.UserProfileAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        allowNull: false,
+        autoIncrement: true
+    },
+    created: {
+        type: sequelize.DATE,
+        allowNull: false,
+        defaultValue: sequelize.NOW
+    },
+    updated: sequelize.DATE,
+    ordering_count: {
+        type: sequelize.INTEGER({ length: 11 }),
+        defaultValue: 0
+    },
+    created_by: {
+        type: sequelize.INTEGER({ length: 11 })
+    },
+    user_id: {
+        type: sequelize.INTEGER({ length: 11 }).UNSIGNED,
+        allowNull: false
+    },
+    first_name: sequelize.STRING(50),
+    last_name: sequelize.STRING(50),
+    display_name: sequelize.STRING(50)
+};
+const UserProfileModel = database_1.default.define("UserProfile", exports.UserProfileAttr, {
+    tableName: 'profiles'
+});
+exports.UserProfileModel = UserProfileModel;

package/models/user/refresh_token.d.ts

@@ -0,0 +1,41 @@
+import * as sequelize from 'sequelize';
+export declare const RefreshTokenAttr: {
+    id: {
+        type: sequelize.StringDataTypeConstructor;
+        primaryKey: boolean;
+        allowNull: boolean;
+    };
+    user_id: {
+        type: sequelize.IntegerDataTypeConstructor;
+        allowNull: boolean;
+        references: {
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            key: string;
+        };
+        onDelete: string;
+    };
+    token: {
+        type: sequelize.TextDataTypeConstructor;
+        allowNull: boolean;
+    };
+    expired_at: {
+        type: sequelize.DateDataTypeConstructor;
+        allowNull: boolean;
+    };
+    organ_id: sequelize.IntegerDataTypeConstructor;
+    group_id: sequelize.IntegerDataTypeConstructor;
+    b2b_group_id: sequelize.IntegerDataTypeConstructor;
+    team_id: sequelize.StringDataType;
+};
+declare const RefreshTokenModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export declare const RefreshAssociation: {
+    access_token: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any) => {
+            as: string;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        };
+    };
+};
+export { RefreshTokenModel };

package/models/user/refresh_token.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshTokenModel = exports.RefreshAssociation = exports.RefreshTokenAttr = void 0;
+const sequelize = require("sequelize");
+const user_1 = require("./user");
+const access_token_1 = require("./access_token");
+const database_1 = require("../../database");
+exports.RefreshTokenAttr = {
+    id: {
+        type: sequelize.STRING,
+        primaryKey: true,
+        allowNull: false
+    },
+    user_id: {
+        type: sequelize.INTEGER,
+        allowNull: false,
+        references: {
+            model: user_1.UserModel,
+            key: "id"
+        },
+        onDelete: "CASCADE"
+    },
+    token: {
+        type: sequelize.TEXT,
+        allowNull: false,
+    },
+    expired_at: {
+        type: sequelize.DATE,
+        allowNull: false
+    },
+    organ_id: sequelize.INTEGER,
+    group_id: sequelize.INTEGER,
+    b2b_group_id: sequelize.INTEGER,
+    team_id: sequelize.STRING(100)
+};
+const RefreshTokenModel = database_1.default.define("RefreshToken", exports.RefreshTokenAttr, {
+    tableName: "refresh_token"
+});
+exports.RefreshTokenModel = RefreshTokenModel;
+exports.RefreshAssociation = {
+    access_token: {
+        model: access_token_1.AccessTokenModel,
+        alias: 'accessToken',
+        join: (ref) => {
+            return {
+                as: exports.RefreshAssociation.access_token.alias,
+                model: exports.RefreshAssociation.access_token.model.schema(ref, "_")
+            };
+        }
+    }
+};

package/models/user/team.d.ts

@@ -0,0 +1,59 @@
+import * as sequelize from "sequelize";
+export declare const UserTeamAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        allowNull: boolean;
+    };
+    created: {
+        type: sequelize.DateDataTypeConstructor;
+        allowNull: boolean;
+    };
+    updated: sequelize.DateDataTypeConstructor;
+    created_by: sequelize.IntegerDataType;
+    organ_id: sequelize.IntegerDataType;
+    ordering_count: sequelize.IntegerDataType;
+    title: sequelize.StringDataType;
+    description: sequelize.StringDataType;
+    default: {
+        type: sequelize.IntegerDataType;
+        defaultValue: number;
+        allowNull: boolean;
+    };
+    shared: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+};
+declare const UserTeamModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export declare const UserUserTeamAttr: {
+    staff_id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        allowNull: boolean;
+    };
+    team_id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        allowNull: boolean;
+    };
+    organ_id: sequelize.IntegerDataType;
+};
+declare const UserUserTeamModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export declare const UserUserTeamAssociation: {
+    staff: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { where, attributes }?: {
+            where?: {};
+            attributes?: any;
+        }) => Promise<{
+            where: {};
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+    };
+};
+export { UserTeamModel, UserUserTeamModel };

package/models/user/team.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUserTeamModel = exports.UserTeamModel = exports.UserUserTeamAssociation = exports.UserUserTeamAttr = exports.UserTeamAttr = void 0;
+const tslib_1 = require("tslib");
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+const user_1 = require("../../models/user/user");
+exports.UserTeamAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        allowNull: false
+    },
+    created: {
+        type: sequelize.DATE,
+        allowNull: false
+    },
+    updated: sequelize.DATE,
+    created_by: sequelize.INTEGER({ length: 11 }),
+    organ_id: sequelize.INTEGER({ length: 11 }),
+    ordering_count: sequelize.INTEGER({ length: 11 }),
+    title: sequelize.STRING(200),
+    description: sequelize.STRING(255),
+    default: {
+        type: sequelize.INTEGER({ length: 11 }),
+        defaultValue: 0,
+        allowNull: false
+    },
+    shared: {
+        type: sequelize.INTEGER({ length: 5 }),
+        allowNull: false,
+        defaultValue: 1
+    }
+};
+const UserTeamModel = database_1.default.define("UserTeam", exports.UserTeamAttr, {
+    tableName: 'teams'
+});
+exports.UserTeamModel = UserTeamModel;
+exports.UserUserTeamAttr = {
+    staff_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        allowNull: false
+    },
+    team_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        allowNull: false
+    },
+    organ_id: sequelize.INTEGER({ length: 11 })
+};
+const UserUserTeamModel = database_1.default.define("UserUserTeam", exports.UserUserTeamAttr, {
+    tableName: 'users_teams'
+});
+exports.UserUserTeamModel = UserUserTeamModel;
+exports.UserUserTeamAssociation = {
+    staff: {
+        model: user_1.UserModel,
+        alias: "staff",
+        join: (ref, { where = {}, attributes = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                where,
+                attributes,
+                model: exports.UserUserTeamAssociation.staff.model.schema(ref, "_"),
+                as: exports.UserUserTeamAssociation.staff.alias
+            };
+        })
+    }
+};
+// staff
+UserUserTeamModel.belongsTo(exports.UserUserTeamAssociation.staff.model, { as: exports.UserUserTeamAssociation.staff.alias, targetKey: "id", foreignKey: "staff_id" });

package/models/user/user.d.ts

@@ -0,0 +1,79 @@
+import * as sequelize from "sequelize";
+export declare const UserAttr: {
+    id: {
+        type: sequelize.IntegerDataTypeConstructor;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+        allowNull: boolean;
+    };
+    email: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+        unique: boolean;
+    };
+    password: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+    };
+    salt: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+        defaultValue: string;
+    };
+    group_id: {
+        type: sequelize.IntegerDataType;
+        defaultValue: number;
+    };
+    ip_address: {
+        type: sequelize.StringDataType;
+    };
+    active: {
+        type: sequelize.IntegerDataType;
+        defaultValue: number;
+    };
+    activation_code: {
+        type: sequelize.StringDataType;
+    };
+    created_on: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+    last_login: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+        defaultValue: number;
+    };
+    username: {
+        type: sequelize.StringDataType;
+    };
+    organ_id: {
+        type: sequelize.IntegerDataType;
+    };
+    member_id: {
+        type: sequelize.StringDataType;
+    };
+    provider: sequelize.StringDataType;
+    mobile: sequelize.StringDataType;
+    mobile_code: sequelize.StringDataType;
+};
+declare const UserModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+declare const UserAssociation: {
+    profile: {
+        attr_user: any[];
+        attr_profile: string[];
+        attributes: (parent?: string) => any[];
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { attributes_all, attributes }?: {
+            attributes_all?: boolean;
+            attributes?: any;
+        }) => Promise<{
+            required: boolean;
+            attributes: any;
+            as: string;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        }>;
+    };
+};
+export { UserModel, UserAssociation };

package/models/user/user.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAssociation = exports.UserModel = exports.UserAttr = void 0;
+const tslib_1 = require("tslib");
+const database_1 = require("../../database");
+const profile_1 = require("./profile");
+const db_1 = require("../../utils/db");
+const sequelize_1 = require("sequelize");
+const sequelize = require("sequelize");
+exports.UserAttr = {
+    id: {
+        type: sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false
+    },
+    email: {
+        type: sequelize.STRING(40),
+        allowNull: false,
+        unique: true
+    },
+    password: {
+        type: sequelize.STRING(100),
+        allowNull: false
+    },
+    salt: {
+        type: sequelize.STRING(7),
+        allowNull: false,
+        defaultValue: ""
+    },
+    group_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        defaultValue: 2
+    },
+    ip_address: {
+        type: sequelize.STRING(45)
+    },
+    active: {
+        type: sequelize.INTEGER({ length: 1 }),
+        defaultValue: 0
+    },
+    activation_code: {
+        type: sequelize.STRING(40)
+    },
+    created_on: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false,
+        defaultValue: 0
+    },
+    last_login: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false,
+        defaultValue: 0
+    },
+    username: {
+        type: sequelize.STRING(20)
+    },
+    organ_id: {
+        type: sequelize.INTEGER({ length: 11 })
+    },
+    // points:sequelize.INTEGER({length:11}),
+    member_id: {
+        type: sequelize.STRING(100)
+    },
+    provider: sequelize.STRING(40),
+    mobile: sequelize.STRING(20),
+    mobile_code: sequelize.STRING(10)
+};
+const UserModel = database_1.default.define("User", exports.UserAttr, {
+    tableName: 'users'
+});
+exports.UserModel = UserModel;
+const UserAssociation = {
+    profile: {
+        attr_user: ['id', 'email', 'username', 'group_id'],
+        attr_profile: ['first_name', 'last_name', 'display_name', 'mobile'],
+        attributes: (parent = "") => {
+            if (parent) {
+                parent = parent + "->";
+            }
+            return UserAssociation.profile.attr_user.concat(UserAssociation.profile.attr_profile.map(i => [(0, sequelize_1.literal)("`" + parent + "profile`." + i), i]));
+        },
+        model: profile_1.UserProfileModel,
+        alias: "profile",
+        join: (ref, { attributes_all = false, attributes = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (attributes_all) {
+                attributes = yield (0, db_1.getFieldAll)(ref + '_' + UserAssociation.profile.model.getTableName());
+            }
+            return {
+                required: false,
+                attributes,
+                as: UserAssociation.profile.alias,
+                model: UserAssociation.profile.model.schema(ref, "_")
+            };
+        })
+    }
+};
+exports.UserAssociation = UserAssociation;
+// profile
+UserModel.hasOne(UserAssociation.profile.model, { as: UserAssociation.profile.alias, foreignKey: { name: 'user_id', allowNull: false } });

package/models/user/user_organ.d.ts

@@ -0,0 +1,52 @@
+import * as sequelize from "sequelize";
+export declare const UserUserOrganTable = "users_organs";
+export declare const UserUserOrganAttr: sequelize.ModelAttributes<sequelize.Model<any, any>, any>;
+declare const UserUserOrganModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export declare const UserUserOrganAssociation: {
+    organ: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { required, where, attributes }?: {
+            required?: boolean;
+            where?: {};
+            attributes?: any;
+        }) => Promise<{
+            where: {};
+            required: boolean;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+    };
+    user: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { attributes }?: {
+            attributes?: any;
+        }) => Promise<{
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+    };
+};
+export declare const UserUserAssociation: {
+    organ: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { where, required, attributes, organ }?: {
+            where?: {};
+            required?: boolean;
+            attributes?: any;
+            organ?: boolean;
+        }) => Promise<{
+            where: {};
+            required: boolean;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+            include: any[];
+        }>;
+    };
+};
+export { UserUserOrganModel };