@digione/node-custom-api 0.0.1

package/utils/user.d.ts

@@ -0,0 +1,61 @@
+import * as sequelize from "sequelize";
+export declare const getUser: (ref: string, index: any, { attributes, attributes_profile, profile, stream_field }?: {
+    attributes?: string[];
+    attributes_profile?: string[];
+    profile?: boolean;
+    stream_field?: any[];
+}) => Promise<sequelize.Model<any, any>>;
+export declare const getOrganMemberId: (ref: string, organ_id: any) => Promise<{
+    member_id: number;
+    setting_user: any;
+}>;
+export declare const createOrgan: (ref: string, input: any, { organ_id, attributes }?: {
+    organ_id?: any;
+    attributes?: string[];
+}) => Promise<{
+    [x: string]: any;
+}>;
+export declare const upsertProfile: (ref: string, user_id: any, input: any, { attributes }?: {
+    attributes?: any[];
+}) => Promise<void>;
+export declare const createUser: (ref: string, input: any, { organ_id, provider, type, attributes, attributes_organ, attributes_profile }?: {
+    organ_id?: string;
+    provider?: string;
+    type?: string;
+    attributes?: any[];
+    attributes_organ?: any;
+    attributes_profile?: any[];
+}) => Promise<{
+    success: number;
+    id: any;
+    organ_id: any;
+}>;
+export declare const getUserInOrgan: (ref: string, { where, organ_id, attributes, parent }?: {
+    where?: {};
+    organ_id?: string;
+    attributes?: string[];
+    parent?: boolean;
+}) => Promise<sequelize.Model<any, any>>;
+export declare const convertAddress: (data: any, { lang_code }?: {
+    lang_code?: string;
+}) => Promise<any>;
+export declare const getCountry: (ref: string, { organ_id, lang_code, setting }?: {
+    organ_id?: string;
+    lang_code?: string;
+    setting?: {};
+}) => Promise<{
+    data: sequelize.Model<any, any>[];
+    default_country: any;
+}>;
+export declare const getGroupSetting: (ref: string, id: any, { attributes }?: {
+    attributes?: string[];
+}) => Promise<any>;
+export declare const getGroupPermission: (ref: string, id: any, module: string, { permission, group_shared, organ_id, attributes }?: {
+    permission?: {};
+    group_shared?: any;
+    organ_id?: number;
+    attributes?: string[];
+}) => Promise<{}>;
+export declare const getB2bSetting: (ref: string, id: any, { attributes }?: {
+    attributes?: string[];
+}) => Promise<any>;

package/utils/user.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getB2bSetting = exports.getGroupPermission = exports.getGroupSetting = exports.getCountry = exports.convertAddress = exports.getUserInOrgan = exports.createUser = exports.upsertProfile = exports.createOrgan = exports.getOrganMemberId = exports.getUser = void 0;
+const tslib_1 = require("tslib");
+const user_1 = require("../models/user/user");
+const organ_1 = require("../models/user/organ");
+const profile_1 = require("../models/user/profile");
+const group_1 = require("../models/user/group");
+const group_permission_1 = require("../models/user/group_permission");
+const b2b_group_1 = require("../models/user/b2b_group");
+const country_1 = require("../models/core/country");
+const city_1 = require("../models/core/city");
+const state_1 = require("../models/core/state");
+const district_1 = require("../models/core/district");
+const stream_1 = require("./stream");
+const helper_1 = require("./helper");
+const redis_1 = require("../database/redis");
+const db_1 = require("./db");
+const errors_1 = require("../errors");
+const sequelize = require("sequelize");
+const _ = require("lodash");
+const sequelize_1 = require("sequelize");
+const sha1 = require('js-sha1');
+const getUser = (ref, index, { attributes = ['id', 'email', 'username', 'group_id'], attributes_profile = ['first_name', 'last_name', 'display_name'], profile = true, stream_field = [] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let include = [];
+    if (profile) {
+        if (stream_field.length)
+            attributes_profile = attributes_profile.concat(['id']);
+        include.push(yield user_1.UserAssociation.profile.join(ref, { attributes: attributes_profile }));
+    }
+    let query = yield user_1.UserModel.schema(ref, "_").findOne({
+        attributes,
+        where: { id: index },
+        include
+    });
+    if (query) {
+        let item = query.toJSON();
+        if (item['parent'] && !item['email']) {
+            let parent = yield user_1.UserModel.schema(ref, "_").findOne({ where: { id: item['parent'] }, raw: true, attributes: ['email'] });
+            if (parent)
+                item['email'] = parent['email'];
+        }
+        if (stream_field.length && item['profile'] && item['profile']['id']) {
+            let query = yield (new stream_1.StreamUtil(ref).getStreamFile('profiles', 'users', {
+                where: { id: item['profile']['id'] }, field_slug: stream_field, img_kit: true
+            }));
+            if (query && query[0])
+                item['profile'] = Object.assign(Object.assign({}, item['profile']), query[0]);
+            delete item['profile']['id'];
+        }
+        let user = _.omit(item, ['profile']);
+        query = Object.assign(Object.assign({}, user), item['profile']);
+    }
+    return query;
+});
+exports.getUser = getUser;
+const getOrganMemberId = (ref, organ_id) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let query = yield organ_1.UserOrganModel.schema(ref, "_").findOne({ where: { id: organ_id }, attributes: ['setting_user'], raw: true });
+    let setting_user = query ? (query['setting_user'] || {}) : {};
+    let member_id = Number(setting_user['member_id'] || '99999');
+    return { member_id, setting_user };
+});
+exports.getOrganMemberId = getOrganMemberId;
+const createOrgan = (ref, input, { organ_id = null, attributes = ['organ_name', 'organ_email', 'organ_phone', 'member_id'] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let organ = _.pick(input, attributes), username = "";
+    if (organ_id) {
+        username = organ_id + "_";
+        organ['parent_id'] = organ_id;
+        if (!organ['member_id']) {
+            let { member_id, setting_user } = yield (0, exports.getOrganMemberId)(ref, organ_id);
+            member_id += 1;
+            setting_user['member_id'] = member_id;
+            organ['member_id'] = member_id;
+            yield (0, db_1.update)(ref, organ_1.UserOrganModel.getTableName().toString(), { setting_user: JSON.stringify(setting_user) }, { where: { id: organ_id } });
+        }
+    }
+    organ['created'] = (0, helper_1.getDateMysql)();
+    let res = yield (0, db_1.insert)(ref, organ_1.UserOrganModel.getTableName().toString(), organ);
+    username = Buffer.from(username + res['id']).toString('base64');
+    yield (0, db_1.update)(ref, organ_1.UserOrganModel.getTableName().toString(), { username }, { where: { id: res['id'] } });
+    return res;
+});
+exports.createOrgan = createOrgan;
+const upsertProfile = (ref, user_id, input, { attributes = [] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let exist = yield profile_1.UserProfileModel.schema(ref, "_").count({ where: { user_id } });
+    if (attributes.length) {
+        input = _.pick(input, attributes);
+    }
+    if (exist) {
+        input['updated'] = (0, helper_1.getDateMysql)();
+        input['dob'] = input['dob'] ? input['dob'] : null;
+        yield (0, db_1.update)(ref, profile_1.UserProfileModel.getTableName().toString(), input, { where: { user_id } });
+    }
+    else {
+        input['user_id'] = user_id;
+        input['created'] = (0, helper_1.getDateMysql)();
+        input['dob'] = input['dob'] ? input['dob'] : null;
+        yield (0, db_1.insert)(ref, profile_1.UserProfileModel.getTableName().toString(), input);
+    }
+});
+exports.upsertProfile = upsertProfile;
+const createUser = (ref, input, { organ_id = "", provider = "email", type = "", attributes = [], attributes_organ = undefined, attributes_profile = [] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const field_join = ['profile', 'organ'];
+    let join = _.pick(input, field_join), new_organ, raw_password;
+    input = _.omit(input, field_join);
+    if (attributes.length) {
+        input = _.pick(input, attributes);
+    }
+    if (!input['password']) {
+        input['password'] = Math.random().toString(36).substring(9);
+        raw_password = input['password'];
+    }
+    input['salt'] = Math.random().toString(36).substring(7);
+    input['password'] = sha1(input['password'] + input['salt']);
+    let where = {};
+    if (organ_id) {
+        where[sequelize_1.Op.or] = [{ organ_id, organ_by: 0 }, { organ_id, organ_by: { [sequelize_1.Op.not]: 0 } }, { organ_by: organ_id }];
+    }
+    if (provider) {
+        where['provider'] = provider;
+    }
+    let exist = yield user_1.UserModel.schema(ref, "_").count({
+        where: Object.assign({ email: input['email'] }, where)
+    });
+    if (exist)
+        return Promise.reject(errors_1.generalError.EMAIL_DUPLICATE);
+    // create organ
+    if (!join['organ'])
+        join['organ'] = { organ_name: input['email'].split('@')[0] };
+    let organ = yield (0, exports.createOrgan)(ref, join['organ'], { organ_id, attributes: attributes_organ });
+    new_organ = organ['id'];
+    input['organ_id'] = new_organ;
+    if (input['email'] && !input['username']) {
+        input['username'] = input['email'].split('@')[0];
+    }
+    if (!input['active']) {
+        input['active'] = 0;
+    }
+    if (!input['group_id']) {
+        let group = yield group_1.UserGroupModel.schema(ref, "_").findOne({
+            where: { shared: 1 }, attributes: ['id'], raw: true
+        });
+        input['group_id'] = group ? group['id'] : 0;
+    }
+    if (provider) {
+        input['provider'] = provider;
+    }
+    input['organ_by'] = organ_id;
+    input['created_on'] = Number((0, helper_1.getDateTime)().format('X'));
+    input['last_login'] = 0;
+    let res = yield (0, db_1.insert)(ref, user_1.UserModel.getTableName().toString(), input);
+    if (join['profile']) {
+        yield (0, exports.upsertProfile)(ref, res['id'], join['profile'], { attributes: attributes_profile });
+    }
+    return { success: 1, id: res['id'], organ_id: new_organ };
+});
+exports.createUser = createUser;
+const getUserInOrgan = (ref, { where = {}, organ_id = "", attributes = ['id', 'organ_id'], parent = true } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let include = [];
+    if (parent && organ_id) {
+        include.push(yield organ_1.UserOrganAssociation.organ.join(ref, { attributes: [] }));
+        let or = { [sequelize_1.Op.or]: where[sequelize_1.Op.or] };
+        let organ = [{ organ_id }, sequelize.literal(`organ.parent_id = '${organ_id}'`)];
+        if (where[sequelize_1.Op.or]) {
+            delete where[sequelize_1.Op.or];
+            where[sequelize_1.Op.and] = [{ [sequelize_1.Op.or]: organ }].concat(or);
+        }
+        else {
+            where[sequelize_1.Op.or] = organ;
+        }
+    }
+    else if (organ_id) {
+        where['organ_id'] = organ_id;
+    }
+    return yield user_1.UserModel.schema(ref, "_").findOne({
+        where, attributes, raw: true, include
+    });
+});
+exports.getUserInOrgan = getUserInOrgan;
+const convertAddress = (data, { lang_code = "en" } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let where = { lang_code: [lang_code, "en"], status: '1' };
+    let order = [sequelize.literal(`FIELD(lang_code,${'\'' + where['lang_code'].join('\',\'') + '\''})`)];
+    if (data['country_id']) {
+        let country = yield country_1.CountryModel.schema("core", "_").findOne({
+            raw: true, where: Object.assign(Object.assign({}, where), { id: data['country_id'] }), attributes: ['country_name'], order
+        });
+        if (country)
+            data['country'] = country['country_name'];
+    }
+    if (data['state_id']) {
+        let state = yield state_1.StateModel.schema("core", "_").findOne({
+            raw: true, where: Object.assign(Object.assign({}, where), { id: data['state_id'] }), attributes: ['state_name'], order
+        });
+        if (state)
+            data['state'] = state['state_name'];
+    }
+    if (data['city_id']) {
+        let city = yield city_1.CityModel.schema("core", "_").findOne({
+            raw: true, where: Object.assign(Object.assign({}, where), { id: data['city_id'] }), attributes: ['city_name'], order
+        });
+        if (city)
+            data['city'] = city['city_name'];
+    }
+    if (data['district_id']) {
+        let district = yield district_1.DistrictModel.schema("core", "_").findOne({
+            raw: true, where: Object.assign(Object.assign({}, where), { id: data['district_id'] }), attributes: ['district_name'], order
+        });
+        if (district)
+            data['district'] = district['district_name'];
+    }
+    return data;
+});
+exports.convertAddress = convertAddress;
+const getCountry = (ref, { organ_id = "", lang_code = "en", setting = {} } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let where = { status: 1, lang_code }, default_country;
+    if (setting['country_id']) {
+        where['id'] = setting['country_id'].split(",");
+    }
+    let data = yield country_1.CountryModel.schema("core", "_").findAll({
+        where, attributes: [['id', 'country_id'], ['mobilecode', 'key'], ['country_name', 'value'], [sequelize.literal('LOWER(country_code)'), 'country_code']], raw: true
+    });
+    if (setting['default_country']) {
+        default_country = data.find(i => i['country_id'] == setting['default_country']);
+    }
+    else {
+        default_country = data[0];
+    }
+    return { data, default_country };
+});
+exports.getCountry = getCountry;
+const getGroupSetting = (ref, id, { attributes = ['id', 'shared', 'setting'] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let index = ref.toLowerCase() + '_' + group_1.UserGroupModel.getTableName();
+    if (redis_1.redisReady) {
+        let setting = yield (0, redis_1.redisHMGet)(index + "_" + id, "setting");
+        if (setting && setting[0]) {
+            return JSON.parse(setting[0]);
+        }
+    }
+    let data = yield group_1.UserGroupModel.schema(ref, "_").findOne({
+        raw: true, where: { id }, attributes
+    });
+    if (data && redis_1.redisReady) {
+        yield (0, redis_1.redisHSet)(index + "_" + id, "setting", JSON.stringify(data));
+    }
+    return data;
+});
+exports.getGroupSetting = getGroupSetting;
+const getGroupPermission = (ref, id, module, { permission = {}, group_shared = undefined, organ_id = 0, attributes = ['id', 'shared', 'setting'] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (typeof group_shared == "undefined") {
+        let setting = yield (0, exports.getGroupSetting)(ref, id, { attributes });
+        if (setting)
+            group_shared = setting['shared'];
+    }
+    if (typeof group_shared != "undefined" && group_shared == 0) {
+        let query = yield group_permission_1.UserGroupPermissionModel.schema(ref, "_").findOne({
+            where: { organ_id, group_id: id, module }, raw: true, attributes: ['roles']
+        });
+        if (query && query['roles']) {
+            let roles = String(query['roles'] || '').split(',').reduce((total, item) => item ? Object.assign(total, { [item]: true }) : total, {});
+            permission = Object.assign(Object.assign({}, permission), roles);
+        }
+    }
+    return permission;
+});
+exports.getGroupPermission = getGroupPermission;
+const getB2bSetting = (ref, id, { attributes = ['id', 'discount', 'discount_type', 'credit_limit'] } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let index = ref.toLowerCase() + '_' + b2b_group_1.B2bGroupModel.getTableName();
+    if (redis_1.redisReady) {
+        let setting = yield (0, redis_1.redisHMGet)(index + "_" + id, "setting");
+        if (setting && setting[0]) {
+            return JSON.parse(setting[0]);
+        }
+    }
+    let data = yield b2b_group_1.B2bGroupModel.schema(ref, "_").findOne({
+        raw: true, where: { id }, attributes
+    });
+    if (data && redis_1.redisReady) {
+        yield (0, redis_1.redisHSet)(index + "_" + id, "setting", JSON.stringify(data));
+    }
+    return data;
+});
+exports.getB2bSetting = getB2bSetting;

package/utils/validator.d.ts

@@ -0,0 +1,56 @@
+import * as Joi from 'joi';
+interface OptionFile {
+    userfiles?: boolean;
+    required?: boolean;
+    fileSize?: number;
+    fileTypes?: string;
+    maxCount?: number;
+    qualityImage?: number;
+    resizeImage?: number;
+}
+export declare const validate: (schema: Joi.AnySchema, body?: any, { arrayIndex, prefixMessage }?: {
+    arrayIndex?: boolean;
+    prefixMessage?: string;
+}) => Promise<any>;
+export declare const validateService: (schema: Joi.ObjectSchema, { organ_id, created_by, web_id, purgeUpdate }?: {
+    organ_id?: boolean;
+    created_by?: boolean;
+    web_id?: boolean;
+    purgeUpdate?: boolean;
+}) => (req: any, res: any, next: any) => Promise<any>;
+export declare const paramService: (schema: Joi.AnySchema) => (req: any, res: any, next: any) => Promise<any>;
+export declare const fileService: (setup: any, { userfiles, required, fileSize, fileTypes, maxCount, qualityImage, resizeImage }?: OptionFile) => (req: any, res: any, next: any) => any;
+export declare const multiService: ({ field, record, record_addition, schema }?: {
+    field?: any;
+    record?: any;
+    record_addition?: any;
+    schema?: {};
+}) => (req: any, res: any, next: any) => Promise<any>;
+export declare const streamService: ({ slug, name_space, param }?: {
+    slug?: string;
+    name_space?: string;
+    param?: string;
+}) => (req: any, res: any, next: any) => Promise<any>;
+export declare const importService: ({ import_type, schema }?: {
+    import_type?: any[];
+    schema?: {};
+}) => (req: any, res: any, next: any) => Promise<any>;
+export declare const exportService: ({ file_type, export_type, limit, schema }?: {
+    file_type?: any;
+    export_type?: any[];
+    limit?: number;
+    schema?: {};
+}) => (req: any, res: any, next: any) => Promise<any>;
+export declare const printService: ({ print_type, schema }?: {
+    print_type?: any[];
+    schema?: {};
+}) => (req: any, res: any, next: any) => Promise<any>;
+export declare const dataService: ({ schema }?: {
+    schema?: {};
+}) => (req: any, res: any, next: any) => Promise<any>;
+export declare const fieldService: ({ field, schema }?: {
+    field?: any[];
+    schema?: {};
+}) => (req: any, res: any, next: any) => Promise<any>;
+export declare const createdByValidate: (req: any, res: any, next: any) => Promise<any>;
+export {};

package/utils/validator.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createdByValidate = exports.fieldService = exports.dataService = exports.printService = exports.exportService = exports.importService = exports.streamService = exports.multiService = exports.fileService = exports.paramService = exports.validateService = exports.validate = void 0;
+const tslib_1 = require("tslib");
+const Joi = require("joi");
+const errors_1 = require("../errors");
+const helper_1 = require("./helper");
+const stream_1 = require("../models/stream/stream");
+const file_1 = require("./file");
+const jimp = require("jimp/dist");
+const _ = require("lodash");
+const validate = (schema, body = {}, { arrayIndex = false, prefixMessage = "" } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const errors = {};
+    const result = schema.validate(body, { abortEarly: false });
+    if (result && result.error && result.error.details) {
+        result.error.details.forEach((v) => {
+            let message = v.message;
+            if (arrayIndex && v.path.length >= 2) {
+                let indexPath = v.path.length - 2, index;
+                if (/^\d+$/.test(String(v.path[indexPath]))) {
+                    index = Number(v.path[indexPath]) + 1;
+                }
+                if (typeof index != "undefined") {
+                    prefixMessage = (prefixMessage || "at row") + ` ${index} `;
+                }
+            }
+            errors[`${v.path[0]}`] = {
+                code: `${v.path.join('.')}.${v.type}${v.context.limit ? `.${v.context.limit}` : ''}`,
+                message: `${prefixMessage}${message}`
+            };
+        });
+    }
+    if (!_.isEmpty(errors)) {
+        return Promise.reject({
+            code: 400 /* HTTP.BAD_REQUEST */,
+            message: 'INVALID_PARAMS',
+            fields: errors
+        });
+    }
+    return result.value;
+});
+exports.validate = validate;
+const validateService = (schema, { organ_id = true, created_by = true, web_id = true, purgeUpdate = true } = {}) => (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (created_by) {
+        const token = req.headers['authorization'] ? req.headers['authorization'].split(' ')[1] : null;
+        if (token && !res.locals.user_id) {
+            try {
+                const data = yield (0, helper_1.getTokenDataFromTokenBySecret)(token, (0, helper_1.getENV)('JWT_SECRET'));
+                if (data && data.id) {
+                    req.body['created_by'] = data.id;
+                }
+            }
+            catch (err) { }
+        }
+        else if (res.locals.user_id) {
+            req.body['created_by'] = res.locals.user_id;
+        }
+        if (purgeUpdate && (req.method == "PUT" || req.method == "PATCH")) {
+            schema = schema.keys({ created_by: Joi.any() });
+            delete req.body['created_by'];
+        }
+    }
+    if (organ_id && res.locals.organ_id) {
+        req.body['organ_id'] = res.locals.organ_id;
+        if (purgeUpdate && (req.method == "PUT" || req.method == "PATCH")) {
+            schema = schema.keys({ organ_id: Joi.any() });
+            delete req.body['organ_id'];
+        }
+    }
+    if (web_id && res.locals.web_id) {
+        req.body['web_id'] = res.locals.web_id;
+    }
+    try {
+        req.body = yield (0, exports.validate)(schema, req.body);
+    }
+    catch (err) {
+        let e = new errors_1.CustomError(err);
+        return res.status(e.code).send(e);
+    }
+    return next();
+});
+exports.validateService = validateService;
+const paramService = (schema) => (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let data = Object.assign(Object.assign({}, req.query), req.params);
+        yield (0, exports.validate)(schema, data);
+    }
+    catch (err) {
+        let e = new errors_1.CustomError(err);
+        return res.status(e.code).send(e);
+    }
+    return next();
+});
+exports.paramService = paramService;
+const fileService = (setup, { userfiles = false, required = false, fileSize = 0, fileTypes = "", maxCount = undefined, qualityImage = 0, resizeImage = 0 } = {}) => (req, res, next) => {
+    let validate = {}, size = 0;
+    fileSize = Number(fileSize || (0, helper_1.getENV)('LIMIT_FILE_SIZE', '0'));
+    if (fileSize) {
+        size = Math.floor(fileSize * 1024 * 1024);
+        validate["limits"] = { fileSize: size };
+    }
+    let option = setup(validate);
+    let upload = userfiles ? option.array("userfiles", maxCount) : option.any();
+    return upload(req, res, (err) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        return (0, exports.validateService)(Joi.object().keys({ tags: Joi.array().allow('', null).items(Joi.object().keys({ slug: Joi.string(), type: Joi.string() })) }).unknown())(req, res, () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            try {
+                let field = userfiles ? "userfiles" : undefined;
+                if (err) {
+                    let code = err['code'];
+                    let message = "upload file not working";
+                    if (err['code'] == "LIMIT_FILE_SIZE") {
+                        const unit = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+                        const i = Math.floor(Math.log(size) / Math.log(1024));
+                        const filesize = parseFloat((size / Math.pow(1024, i)).toFixed(2));
+                        message = `file size limit is ${filesize} ${unit[i]}`;
+                    }
+                    else if (err['code'] == "LIMIT_UNEXPECTED_FILE") {
+                        message = `file max total is ${maxCount}`;
+                    }
+                    yield (0, errors_1.paramError)(message, { field, code });
+                }
+                if (required && (!req.files || !req.files.length)) {
+                    yield (0, errors_1.paramError)(`${field || 'file'} is required`, { field });
+                }
+                if (req.files && (fileTypes || qualityImage || resizeImage)) {
+                    const regxType = fileTypes ? new RegExp('\\b' + fileTypes + '\\b') : null;
+                    const regxImage = (qualityImage || resizeImage) ? new RegExp('\\b' + 'jpeg|jpg|png|bmp' + '\\b') : null;
+                    let errorType = false;
+                    for (let file of req.files) {
+                        if (regxType && !regxType.test(file.mimetype)) {
+                            field = file['fieldname'];
+                            errorType = true;
+                            continue;
+                        }
+                        if (regxImage && regxImage.test(file.mimetype)) {
+                            try {
+                                let image = yield jimp.read(file.buffer);
+                                if (resizeImage && image.bitmap.width > resizeImage) {
+                                    image.resize(resizeImage, jimp.AUTO);
+                                }
+                                else if (qualityImage) {
+                                    image.resize((image.bitmap.width * (qualityImage / 100)), jimp.AUTO);
+                                }
+                                if (qualityImage)
+                                    image.quality(qualityImage);
+                                let buffer = yield (0, file_1.getBuffer)(image, { mimetype: file.mimetype });
+                                file.buffer = buffer;
+                                file.size = buffer.toString().length;
+                            }
+                            catch (err) { }
+                        }
+                    }
+                    if (errorType)
+                        yield (0, errors_1.paramError)(`file require type ${fileTypes}`, { field, code: "FILE_TYPE_NOT_ALLOW" });
+                }
+            }
+            catch (err) {
+                let e = new errors_1.CustomError(err);
+                return res.status(e.code).send(e);
+            }
+            return next();
+        }));
+    }));
+};
+exports.fileService = fileService;
+const multiService = ({ field = undefined, record = undefined, record_addition = undefined, schema = {} } = {}) => {
+    let value_schema = Joi.any().when('field', { is: Joi.exist(), then: Joi.required() });
+    let field_schema = (field || {});
+    record = record || Object.assign({ ordering_count: Joi.number().min(0) }, (record_addition || {}));
+    field = Object.keys(field_schema);
+    if (field.length) {
+        value_schema = Joi.any().when('field', {
+            switch: field.map((key) => {
+                return { is: key, then: field_schema[key].required() };
+            })
+        });
+        schema['field'] = Joi.string().valid(...field);
+        schema['value'] = value_schema;
+    }
+    return (0, exports.validateService)(Joi.object().keys(Object.assign(Object.assign({}, schema), { records: Joi.array().items(Joi.object().keys(Object.assign({ id: Joi.number().required() }, record)).options({ stripUnknown: true })).min(1).required() })).options({ stripUnknown: true }));
+};
+exports.multiService = multiService;
+const streamService = ({ slug = "", name_space = "", param = "index" } = {}) => (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let ref = res.locals.ref, post_stream = (req.query[param] || '');
+        if (req.body)
+            post_stream = req.body[param] || post_stream;
+        let stream_slug = slug + post_stream;
+        let stream_namespace = name_space || stream_slug;
+        let query = yield stream_1.StreamModel.schema(ref, "_").findOne({
+            where: { stream_slug, stream_namespace }, attributes: ['id'], raw: true
+        });
+        if (query) {
+            let stream_id = query['id'];
+            res.locals.option = Object.assign(Object.assign({}, (res.locals.option || {})), { stream_id });
+            if (req.body)
+                req.body['stream_id'] = stream_id;
+            return next();
+        }
+    }
+    catch (err) { }
+    let e = new errors_1.CustomError(errors_1.generalError.NOT_FOUND);
+    return res.status(e.code).send(e);
+});
+exports.streamService = streamService;
+const importService = ({ import_type = [], schema = {} } = {}) => (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    return (0, exports.validateService)(Joi.object().keys(Object.assign({ import_type: Joi.string().valid(...import_type) }, schema)).unknown())(req, res, next);
+});
+exports.importService = importService;
+const exportService = ({ file_type = undefined, export_type = [], limit = 200, schema = {} } = {}) => (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    res.locals.option = (res.locals.option || {});
+    res.locals.option['limit'] = res.locals.option['limit'] || limit;
+    if (req.query.all_data) {
+        res.locals.option['all_data'] = req.query.all_data;
+    }
+    if (file_type) {
+        if (!req.query.file_type) {
+            req.query.file_type = file_type[0];
+        }
+        schema['file_type'] = Joi.string().valid(...file_type);
+    }
+    if (req.query.file_type) {
+        res.locals.option['file_type'] = req.query.file_type;
+    }
+    if (export_type && !req.query.export_type) {
+        req.query.export_type = export_type[0];
+    }
+    if (req.query.export_type) {
+        res.locals.option['export_type'] = req.query.export_type;
+    }
+    return (0, exports.paramService)(Joi.object().keys(Object.assign({ all_data: Joi.number().allow(null, ''), export_type: Joi.string().valid(...export_type), limit: Joi.number().max(limit) }, schema)).unknown())(req, res, next);
+});
+exports.exportService = exportService;
+const printService = ({ print_type = [], schema = {} } = {}) => (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (req.query.ids) {
+        res.locals.option = Object.assign(Object.assign({}, (res.locals.option || {})), { ids: String(req.query.ids).split(',') });
+    }
+    if (print_type && !req.query.print_type) {
+        req.query.print_type = print_type[0];
+    }
+    if (req.query.print_type) {
+        res.locals.option = Object.assign(Object.assign({}, (res.locals.option || {})), { print_type: req.query.print_type });
+    }
+    if (req.query.preset) {
+        res.locals.option = Object.assign(Object.assign({}, (res.locals.option || {})), { preset: req.query.preset });
+    }
+    return (0, exports.paramService)(Joi.object().keys(Object.assign({ ids: Joi.string().required(), print_type: Joi.string().valid(...print_type), preset: Joi.string() }, schema)).unknown())(req, res, next);
+});
+exports.printService = printService;
+const dataService = ({ schema = {} } = {}) => (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (req.query.ids) {
+        res.locals.option = Object.assign(Object.assign({}, (res.locals.option || {})), { ids: String(req.query.ids).split(',') });
+    }
+    return (0, exports.paramService)(Joi.object().keys(Object.assign({ ids: Joi.string().required(), preset: Joi.string() }, schema)).unknown())(req, res, next);
+});
+exports.dataService = dataService;
+const fieldService = ({ field = [], schema = {} } = {}) => (req, res, next) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (field && !req.query.field) {
+        req.query.field = field[0];
+    }
+    if (req.query.field) {
+        res.locals.option = Object.assign(Object.assign({}, (res.locals.option || {})), { field: req.query.field });
+    }
+    return (0, exports.paramService)(Joi.object().keys(Object.assign({ field: Joi.string().valid(...field) }, schema)).unknown())(req, res, next);
+});
+exports.fieldService = fieldService;
+exports.createdByValidate = (0, exports.validateService)(Joi.object().keys({
+    created_by: Joi.alternatives().try(Joi.string(), Joi.number()).required()
+}).unknown());