@digione/node-custom-api 0.0.1

package/middlewares/systemSite.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySubOrgan = exports.verifyAccess = exports.verifyVendor = exports.organByWeb = exports.site = void 0;
+const tslib_1 = require("tslib");
+const errors_1 = require("../errors");
+const website_1 = require("../models/system/website");
+const organ_1 = require("../models/user/organ");
+const accessToken_1 = require("./accessToken");
+const authError_1 = require("../errors/authError");
+const site = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let ref = res.locals.ref;
+    let web = req.params.web || req.params.web_system;
+    if (web && !req.params.web_system_token) {
+        let exist = yield website_1.SystemWebSiteModel.schema(ref, "_").count({ where: { id: web, module: "core" } });
+        if (!exist) {
+            let err = new errors_1.CustomError(errors_1.generalError.NOT_FOUND);
+            return res.status(err.code).send(err);
+        }
+    }
+    if (web)
+        res.locals.web_id = web;
+    return next();
+});
+exports.site = site;
+const organByWeb = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let ref = res.locals.ref;
+    let web = req.params.web || req.params.web_system;
+    if (web && req.params.web_system_token) {
+        let query = yield website_1.SystemWebSiteModel.schema(ref, "_").findOne({ where: { id: web, module: "core" }, attributes: ['organ_id'], raw: true });
+        if (query && query['organ_id']) {
+            res.locals.web_id = web;
+            res.locals.organ_id = query['organ_id'];
+            res.locals.verify_organ = 1;
+            return next();
+        }
+    }
+    let err = new errors_1.CustomError(errors_1.generalError.NOT_FOUND);
+    return res.status(err.code).send(err);
+});
+exports.organByWeb = organByWeb;
+const verifyVendor = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    return (0, accessToken_1.verifyAccessToken)(req, res, () => {
+        let organ_id = res.locals.organ_id;
+        let auth_id = res.locals.auth_id;
+        return (0, exports.organByWeb)(req, res, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let parent_id = res.locals.organ_id;
+            if (organ_id == parent_id)
+                return next();
+            let exist = yield organ_1.UserOrganModel.schema(res.locals.ref, "_").count({
+                where: { id: organ_id, parent_id }
+            });
+            if (exist) {
+                res.locals.parent_organ_id = res.locals.organ_id;
+                res.locals.organ_id = organ_id;
+                res.locals.auth_id = auth_id;
+                return next();
+            }
+            let err = new errors_1.CustomError(authError_1.authError.ACCESS_DENINED);
+            return res.status(403 /* HTTP.FORBIDDEN */).send(err);
+        }));
+    });
+});
+exports.verifyVendor = verifyVendor;
+const verifyAccess = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (req.params.web_system_token) {
+        return (0, accessToken_1.accessToken)(req, res, () => {
+            return (0, exports.organByWeb)(req, res, next);
+        });
+    }
+    return res.status(403 /* HTTP.FORBIDDEN */).send({
+        code: 403 /* HTTP.FORBIDDEN */,
+        json: { code: authError_1.authError.ACCESS_DENINED.message }
+    });
+});
+exports.verifyAccess = verifyAccess;
+const verifySubOrgan = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let body = req.body || {};
+    let organ_id = body['organ_id'] || req.query.organ_in;
+    organ_id = organ_id || res.locals.related_id;
+    if (organ_id) {
+        let parent_id = [res.locals.organ_id];
+        if (body['organ_id']) {
+            req.body['created_by'] = "0";
+        }
+        if (organ_id == parent_id[0])
+            return next();
+        if (res.locals.related_id && res.locals.related_id != parent_id[0]) {
+            parent_id.push(res.locals.related_id);
+        }
+        let exist = yield organ_1.UserOrganModel.schema(res.locals.ref, "_").count({
+            where: { id: organ_id, parent_id }
+        });
+        if (exist) {
+            res.locals.parent_organ_id = res.locals.organ_id;
+            res.locals.organ_id = organ_id;
+            res.locals.verify_organ = 1;
+            return next();
+        }
+        return res.status(403 /* HTTP.FORBIDDEN */).send({
+            code: 403 /* HTTP.FORBIDDEN */,
+            json: { code: authError_1.authError.ACCESS_DENINED.message }
+        });
+    }
+    return next();
+});
+exports.verifySubOrgan = verifySubOrgan;

package/middlewares/webSite.d.ts

@@ -0,0 +1,7 @@
+import { Request, Response } from 'express';
+export declare const site: (req: Request, res: Response, next: any) => Promise<any>;
+export declare const themeByWeb: (req: Request, res: Response, next: any) => Promise<any>;
+export declare const configByWeb: (req: Request, res: Response, next: any) => Promise<any>;
+export declare const organByWeb: (req: Request, res: Response, next: any) => Promise<any>;
+export declare const verifyVendor: (req: Request, res: Response, next: any) => Promise<any>;
+export declare const verifyVendorOrganWeb: (req: Request, res: Response, next: any) => Promise<any>;

package/middlewares/webSite.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyVendorOrganWeb = exports.verifyVendor = exports.organByWeb = exports.configByWeb = exports.themeByWeb = exports.site = void 0;
+const tslib_1 = require("tslib");
+const errors_1 = require("../errors");
+const website_1 = require("../models/system/website");
+const organ_1 = require("../models/user/organ");
+const accessToken_1 = require("../middlewares/accessToken");
+const authError_1 = require("../errors/authError");
+const site = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let ref = res.locals.ref;
+    let web = req.params.web;
+    if (web && !req.params.web_token) {
+        let exist = yield website_1.SystemWebSiteModel.schema(ref, "_").count({ where: { id: web, module: "site" } });
+        if (!exist) {
+            let err = new errors_1.CustomError(errors_1.generalError.NOT_FOUND);
+            return res.status(err.code).send(err);
+        }
+    }
+    if (web)
+        res.locals.web_id = web;
+    return next();
+});
+exports.site = site;
+const themeByWeb = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let ref = res.locals.ref;
+    let web = req.params.web;
+    if (web) {
+        let query = yield website_1.SystemWebSiteModel.schema(ref, "_").findOne({ where: { id: web, module: "site" }, attributes: ['organ_id', 'theme_id'], raw: true });
+        if (query) {
+            res.locals.web_id = web;
+            res.locals.organ_id = query['organ_id'];
+            res.locals.verify_organ = 1;
+            res.locals.theme_id = query['theme_id'];
+            return next();
+        }
+    }
+    let err = new errors_1.CustomError(errors_1.generalError.NOT_FOUND);
+    return res.status(err.code).send(err);
+});
+exports.themeByWeb = themeByWeb;
+const configByWeb = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let ref = res.locals.ref;
+    let web = req.params.web;
+    if (web) {
+        let query = yield website_1.SystemWebSiteModel.schema(ref, "_").findOne({ where: { id: web, module: "site" }, attributes: ['created_by', 'organ_id', 'config'], raw: true });
+        if (query && query['created_by']) {
+            res.locals.web_id = web;
+            res.locals.auth_id = query['created_by'];
+            res.locals.organ_id = query['organ_id'];
+            res.locals.verify_organ = 1;
+            let body = req.body || {};
+            body['created_by'] = query['created_by'];
+            body['data'] = query['config'] || {};
+            req.body = body;
+            return next();
+        }
+    }
+    let err = new errors_1.CustomError(errors_1.generalError.NOT_FOUND);
+    return res.status(err.code).send(err);
+});
+exports.configByWeb = configByWeb;
+const organByWeb = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let ref = res.locals.ref;
+    let web = req.params.web;
+    if (web) {
+        let query = yield website_1.SystemWebSiteModel.schema(ref, "_").findOne({ where: { id: web, module: "site" }, attributes: ['created_by', 'organ_id'], raw: true });
+        if (query && query['organ_id']) {
+            res.locals.web_id = web;
+            res.locals.organ_id = query['organ_id'];
+            res.locals.verify_organ = 1;
+            return next();
+        }
+    }
+    let err = new errors_1.CustomError(errors_1.generalError.NOT_FOUND);
+    return res.status(err.code).send(err);
+});
+exports.organByWeb = organByWeb;
+const verifyVendor = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    return (0, accessToken_1.verifyAccessToken)(req, res, () => {
+        let organ_id = res.locals.organ_id;
+        let auth_id = res.locals.auth_id;
+        return (0, exports.organByWeb)(req, res, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let exist = (organ_id == res.locals.organ_id) ? 1 : 0;
+            if (!exist) {
+                exist = yield organ_1.UserOrganModel.schema(res.locals.ref, "_").count({
+                    where: { id: organ_id, parent_id: res.locals.organ_id }
+                });
+            }
+            if (exist) {
+                res.locals.parent_organ_id = res.locals.organ_id;
+                res.locals.organ_id = organ_id;
+                res.locals.auth_id = auth_id;
+                return next();
+            }
+            let err = new errors_1.CustomError(authError_1.authError.ACCESS_DENINED);
+            return res.status(403 /* HTTP.FORBIDDEN */).send(err);
+        }));
+    });
+});
+exports.verifyVendor = verifyVendor;
+const verifyVendorOrganWeb = (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    return (0, exports.verifyVendor)(req, res, () => {
+        res.locals.organ_id = res.locals.parent_organ_id;
+        delete res.locals.parent_organ_id;
+        return next();
+    });
+});
+exports.verifyVendorOrganWeb = verifyVendorOrganWeb;

package/models/core/city.d.ts

@@ -0,0 +1,66 @@
+import * as sequelize from "sequelize";
+export declare const CityTable = "cities";
+export declare const CityAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+        allowNull: boolean;
+    };
+    city_name: sequelize.StringDataType;
+    state_id: sequelize.IntegerDataType;
+    status: sequelize.IntegerDataType;
+    ordering: sequelize.IntegerDataType;
+    lang_code: sequelize.StringDataType;
+};
+declare const CityModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+declare const CityAssociation: {
+    state: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { where, attributes, required, zone_country }?: {
+            where?: {};
+            attributes?: any;
+            required?: any;
+            zone_country?: boolean;
+        }) => Promise<{
+            where: {};
+            required: any;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+            include: any[];
+        }>;
+    };
+    zone: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { where, attributes, required }?: {
+            where?: {};
+            attributes?: any;
+            required?: any;
+        }) => Promise<{
+            where: {};
+            required: any;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+    };
+    zone_state: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { where, attributes, required }?: {
+            where?: {};
+            attributes?: any;
+            required?: any;
+        }) => Promise<{
+            where: {};
+            required: any;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+    };
+};
+export { CityModel, CityAssociation };

package/models/core/city.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CityAssociation = exports.CityModel = exports.CityAttr = exports.CityTable = void 0;
+const tslib_1 = require("tslib");
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+const state_1 = require("./state");
+const zone_1 = require("../system/zone");
+exports.CityTable = "cities";
+exports.CityAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false
+    },
+    city_name: sequelize.STRING(200),
+    state_id: sequelize.INTEGER({ length: 11 }),
+    status: sequelize.INTEGER({ length: 11 }),
+    ordering: sequelize.INTEGER({ length: 11 }),
+    lang_code: sequelize.STRING(20)
+};
+const CityModel = database_1.default.define("City", exports.CityAttr, {
+    tableName: exports.CityTable
+});
+exports.CityModel = CityModel;
+const CityAssociation = {
+    state: {
+        model: state_1.StateModel,
+        alias: "state",
+        join: (ref, { where = {}, attributes = undefined, required = undefined, zone_country = false } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let include = [];
+            if (zone_country) {
+                include.push(yield state_1.StateAssociation.zone_country.join(ref, { required: false, attributes: [] }));
+            }
+            return {
+                where,
+                required,
+                attributes,
+                model: CityAssociation.state.model.schema("core", "_"),
+                as: CityAssociation.state.alias,
+                include
+            };
+        })
+    },
+    zone: {
+        model: zone_1.ZoneCityModel,
+        alias: "zone",
+        join: (ref, { where = {}, attributes = undefined, required = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                where,
+                required,
+                attributes,
+                model: CityAssociation.zone.model.schema(ref, "_"),
+                as: CityAssociation.zone.alias
+            };
+        })
+    },
+    zone_state: {
+        model: zone_1.ZoneStateModel,
+        alias: "zone_state",
+        join: (ref, { where = {}, attributes = undefined, required = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                where,
+                required,
+                attributes,
+                model: CityAssociation.zone_state.model.schema(ref, "_"),
+                as: CityAssociation.zone_state.alias
+            };
+        })
+    }
+};
+exports.CityAssociation = CityAssociation;
+// state
+CityModel.belongsTo(CityAssociation.state.model, { as: CityAssociation.state.alias, foreignKey: "state_id", targetKey: "id" });
+// zone
+CityModel.hasOne(CityAssociation.zone.model, { as: CityAssociation.zone.alias, foreignKey: "city_id" });
+// zone state
+CityModel.belongsTo(CityAssociation.zone_state.model, { as: CityAssociation.zone_state.alias, foreignKey: "state_id", targetKey: "state_id" });

package/models/core/country.d.ts

@@ -0,0 +1,35 @@
+import * as sequelize from "sequelize";
+export declare const CountryTable = "country";
+export declare const CountryAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+        allowNull: boolean;
+    };
+    country_name: sequelize.StringDataType;
+    default: sequelize.StringDataType;
+    status: sequelize.StringDataType;
+    ordering: sequelize.IntegerDataType;
+    country_code: sequelize.StringDataType;
+    lang_code: sequelize.StringDataType;
+};
+declare const CountryModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+declare const CountryAssociation: {
+    zone: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { where, attributes, required }?: {
+            where?: {};
+            attributes?: any;
+            required?: any;
+        }) => Promise<{
+            where: {};
+            required: any;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+    };
+};
+export { CountryModel, CountryAssociation };

package/models/core/country.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountryAssociation = exports.CountryModel = exports.CountryAttr = exports.CountryTable = void 0;
+const tslib_1 = require("tslib");
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+const zone_1 = require("../system/zone");
+exports.CountryTable = "country";
+exports.CountryAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false
+    },
+    country_name: sequelize.STRING(200),
+    default: sequelize.STRING(20),
+    status: sequelize.STRING(20),
+    ordering: sequelize.INTEGER({ length: 11 }),
+    country_code: sequelize.STRING(20),
+    lang_code: sequelize.STRING(20)
+};
+const CountryModel = database_1.default.define("Country", exports.CountryAttr, {
+    tableName: exports.CountryTable
+});
+exports.CountryModel = CountryModel;
+const CountryAssociation = {
+    zone: {
+        model: zone_1.ZoneCountryModel,
+        alias: "zone",
+        join: (ref, { where = {}, attributes = undefined, required = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                where,
+                required,
+                attributes,
+                model: CountryAssociation.zone.model.schema(ref, "_"),
+                as: CountryAssociation.zone.alias
+            };
+        })
+    }
+};
+exports.CountryAssociation = CountryAssociation;
+// zone
+CountryModel.hasOne(CountryAssociation.zone.model, { as: CountryAssociation.zone.alias, foreignKey: "country_id" });

package/models/core/district.d.ts

@@ -0,0 +1,17 @@
+import * as sequelize from "sequelize";
+export declare const DistrictTable = "districts";
+export declare const DistrictAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+        allowNull: boolean;
+    };
+    district_name: sequelize.StringDataType;
+    city_id: sequelize.IntegerDataType;
+    status: sequelize.IntegerDataType;
+    ordering: sequelize.IntegerDataType;
+    lang_code: sequelize.StringDataType;
+};
+declare const DistrictModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export { DistrictModel };

package/models/core/district.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistrictModel = exports.DistrictAttr = exports.DistrictTable = void 0;
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+exports.DistrictTable = "districts";
+exports.DistrictAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false
+    },
+    district_name: sequelize.STRING(200),
+    city_id: sequelize.INTEGER({ length: 11 }),
+    status: sequelize.INTEGER({ length: 11 }),
+    ordering: sequelize.INTEGER({ length: 11 }),
+    lang_code: sequelize.STRING(20)
+};
+const DistrictModel = database_1.default.define("District", exports.DistrictAttr, {
+    tableName: exports.DistrictTable
+});
+exports.DistrictModel = DistrictModel;

package/models/core/domain.d.ts

@@ -0,0 +1,57 @@
+import * as sequelize from "sequelize";
+export declare const CoreDomainAttr: {
+    id: {
+        type: sequelize.IntegerDataType;
+        primaryKey: boolean;
+        autoIncrement: boolean;
+        allowNull: boolean;
+    };
+    domain: {
+        type: sequelize.StringDataType;
+        allowNull: boolean;
+        unique: boolean;
+    };
+    site_id: {
+        type: sequelize.IntegerDataType;
+        allowNull: boolean;
+    };
+    type: {
+        type: sequelize.EnumDataType<"park" | "redirect" | "site">;
+        allowNull: boolean;
+        defaultValue: string;
+    };
+    settings: {
+        type: sequelize.StringDataType;
+    };
+};
+declare const CoreDomainModel: sequelize.ModelCtor<sequelize.Model<any, any>>;
+export declare const CoreDomainAssociation: {
+    ref: {
+        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 CoreSiteAssociation: {
+    domain: {
+        model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+        alias: string;
+        join: (ref: any, { attributes, required }?: {
+            attributes?: any;
+            required?: boolean;
+        }) => Promise<{
+            required: boolean;
+            attributes: any;
+            model: sequelize.ModelCtor<sequelize.Model<any, any>>;
+            as: string;
+        }>;
+        get: (ref: any, index: any) => Promise<sequelize.Model<any, any>[]>;
+    };
+};
+export { CoreDomainModel };

package/models/core/domain.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreDomainModel = exports.CoreSiteAssociation = exports.CoreDomainAssociation = exports.CoreDomainAttr = void 0;
+const tslib_1 = require("tslib");
+const sequelize = require("sequelize");
+const database_1 = require("../../database");
+const db_1 = require("../../utils/db");
+const site_1 = require("./site");
+exports.CoreDomainAttr = {
+    id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false
+    },
+    domain: {
+        type: sequelize.STRING(100),
+        allowNull: false,
+        unique: true
+    },
+    site_id: {
+        type: sequelize.INTEGER({ length: 11 }),
+        allowNull: false
+    },
+    type: {
+        type: sequelize.ENUM('park', 'redirect', 'site'),
+        allowNull: false,
+        defaultValue: 'park'
+    },
+    settings: {
+        type: sequelize.STRING(250)
+    }
+};
+const CoreDomainModel = database_1.default.define("CoreDomain", exports.CoreDomainAttr, {
+    tableName: 'domains'
+});
+exports.CoreDomainModel = CoreDomainModel;
+exports.CoreDomainAssociation = {
+    ref: {
+        model: site_1.CoreSiteModel,
+        alias: "ref_row",
+        join: (ref, { attributes = [] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            if (!attributes.length) {
+                attributes = yield (0, db_1.getFieldAll)(ref + "_" + site_1.CoreSiteModel.getTableName().toString());
+            }
+            return {
+                attributes,
+                model: exports.CoreDomainAssociation.ref.model.schema(ref, "_"),
+                as: exports.CoreDomainAssociation.ref.alias
+            };
+        })
+    }
+};
+exports.CoreSiteAssociation = {
+    domain: {
+        model: CoreDomainModel,
+        alias: "domains",
+        join: (ref, { attributes = undefined, required = false } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            return {
+                required,
+                attributes,
+                model: exports.CoreSiteAssociation.domain.model.schema(ref, "_"),
+                as: exports.CoreSiteAssociation.domain.alias
+            };
+        }),
+        get: (ref, index) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            let query = yield exports.CoreSiteAssociation.domain.model.schema(ref, "_").findAll({
+                where: { site_id: index }, raw: true, attributes: ['*']
+            });
+            return query;
+        })
+    }
+};
+CoreDomainModel.belongsTo(exports.CoreDomainAssociation.ref.model, { as: exports.CoreDomainAssociation.ref.alias, foreignKey: "site_id", targetKey: "id" });
+site_1.CoreSiteModel.hasMany(exports.CoreSiteAssociation.domain.model, { as: exports.CoreSiteAssociation.domain.alias, foreignKey: "site_id" });