@digione/node-custom-api 0.0.1

package/utils/language.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageUtil = void 0;
+const tslib_1 = require("tslib");
+const sequelize_1 = require("sequelize");
+const language_1 = require("../models/system/language");
+const website_1 = require("../models/system/website");
+class LanguageUtil {
+    constructor(ref, option) {
+        this.ref = ref;
+        this.option = option || {};
+    }
+    getLangsAll({ where = {} } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield language_1.SystemLanguageModel.schema(this.ref, "_").findAll({
+                attributes: ['id', 'status', ['referent_language', 'lang_code']], where, raw: true
+            });
+        });
+    }
+    getLangsLive({ where = {}, attr_include = [] } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let include = [];
+            where['status'] = 'yes';
+            if (this.option.web_id) {
+                include.push({
+                    required: true,
+                    attributes: [],
+                    where: { web_id: this.option.web_id, type: "language" },
+                    model: website_1.SystemWebSiteRelationModel.schema(this.ref, "_"),
+                    association: new sequelize_1.HasOne(language_1.SystemLanguageModel, website_1.SystemWebSiteRelationModel, { as: "web", foreignKey: "row_id", constraints: false })
+                });
+            }
+            return yield language_1.SystemLanguageModel.schema(this.ref, "_").findAll({
+                attributes: ['id', 'status', ['referent_language', 'lang_code'], ...attr_include], where, include, raw: true
+            });
+        });
+    }
+    existLang(lang_code) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let exist = yield language_1.SystemLanguageModel.schema(this.ref).count({ where: { lang_code, status: 'yes' } });
+            if (exist > 0) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+}
+exports.LanguageUtil = LanguageUtil;

package/utils/metadata.d.ts

@@ -0,0 +1,18 @@
+interface OptionMetadata {
+    organ_id?: string | number;
+    [index: string]: any;
+}
+export declare class MetadataUtil {
+    ref: string;
+    option: OptionMetadata;
+    constructor(ref: string, option?: OptionMetadata);
+    upsert(row_id: any, module: string, input?: any, { addition, items, autoType, types, str_length, attributes }?: {
+        addition?: {};
+        items?: {};
+        autoType?: boolean;
+        types?: string;
+        str_length?: number;
+        attributes?: string[];
+    }): Promise<import("sequelize").Model<any, any>[]>;
+}
+export {};

package/utils/metadata.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataUtil = void 0;
+const tslib_1 = require("tslib");
+const metadata_1 = require("../models/system/metadata");
+const helper_1 = require("./helper");
+const _ = require("lodash");
+class MetadataUtil {
+    constructor(ref, option) {
+        this.ref = ref;
+        this.option = option || {};
+    }
+    upsert(row_id, module, input = {}, { addition = {}, items = {}, autoType = false, types = "name", str_length = 255, attributes = ['row_id', 'module', 'related_id', 'organ_id', 'web_id'] } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            addition = Object.assign(Object.assign({}, addition), _.pick(input, attributes));
+            input = _.omit(input, attributes);
+            if (typeof addition['id'] == "undefined") {
+                let query = yield metadata_1.MetadataModel.schema(this.ref, "_").findOne({
+                    where: { row_id, module }, raw: true, attributes: ['id', 'items']
+                });
+                if (query)
+                    addition = {};
+                addition['id'] = query ? query['id'] : undefined;
+                items = query ? (query['items'] || {}) : {};
+            }
+            Object.keys(input).forEach(key => {
+                let value = {}, type = types;
+                if (_.isObject(input[key])) {
+                    let val = {};
+                    _.each(input[key], (v, k) => { val['value_' + k] = (0, helper_1.stripHtml)(v ? v.substring(0, str_length) : ""); });
+                    value = val;
+                }
+                else {
+                    value = { value_en: (0, helper_1.stripHtml)(String(input[key] || "").substring(0, str_length)) };
+                }
+                if (autoType && !items[key]) {
+                    let str = key.split(":");
+                    if (str.length == 1)
+                        str[1] = types;
+                    type = str[0];
+                    str.shift();
+                    key = str.join(":");
+                }
+                items[key] = Object.assign({ types: type }, value);
+            });
+            return yield metadata_1.MetadataModel.schema(this.ref, "_").bulkCreate([Object.assign(Object.assign({ row_id, module }, addition), { items })], { updateOnDuplicate: ['items'] });
+        });
+    }
+}
+exports.MetadataUtil = MetadataUtil;

package/utils/session.d.ts

@@ -0,0 +1,37 @@
+interface Option {
+    auth_id?: string;
+    organ_id?: string;
+    sid?: string;
+    [index: string]: any;
+}
+export declare class SessionUtil {
+    ref: string;
+    option: Option;
+    constructor(ref: string, option?: Option);
+    setSession(key: string, value: any, { index, input }?: {
+        index?: any;
+        input?: {};
+    }): Promise<{
+        sid: string;
+        session: {};
+    }>;
+    getSession(index?: string): Promise<{
+        sid: string;
+        session: {};
+    }>;
+    getSessionByKey(key: string, { sid, defaultValue }?: {
+        sid?: any;
+        defaultValue?: {};
+    }): Promise<any>;
+    setOrderBy(key: string, value: any, { index }?: {
+        index?: any;
+    }): Promise<{
+        success: number;
+    }>;
+    getOrderBy(key: string, { index }?: {
+        index?: any;
+    }): Promise<{
+        items: any[];
+    }>;
+}
+export {};

package/utils/session.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionUtil = void 0;
+const tslib_1 = require("tslib");
+const session_1 = require("../models/system/session");
+class SessionUtil {
+    constructor(ref, option) {
+        this.ref = ref;
+        this.option = option;
+    }
+    setSession(key, value, { index = null, input = {} } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let { sid, session } = yield this.getSession(index);
+            if (sid) {
+                session[key] = value;
+                yield session_1.SessionModel.schema(this.ref, "_").bulkCreate([Object.assign(Object.assign({ sid }, input), { session: JSON.stringify(session) })], { updateOnDuplicate: ['session'] });
+            }
+            return { sid, session };
+        });
+    }
+    getSession(index) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let sid = (index || this.option.auth_id || this.option.sid), session = {};
+            if (sid) {
+                let query = yield session_1.SessionModel.schema(this.ref, "_").findOne({ where: { sid }, raw: true, attributes: ['session'] });
+                session = (query && query['session']) ? JSON.parse(query['session']) : {};
+            }
+            return { sid, session };
+        });
+    }
+    getSessionByKey(key, { sid = null, defaultValue = {} } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let { session } = yield this.getSession(sid);
+            return session[key] || defaultValue;
+        });
+    }
+    setOrderBy(key, value, { index = null } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let { sid, session } = yield this.getSession(index);
+            if (sid) {
+                session[key] = session[key] || {};
+                session[key][value] = new Date().getTime();
+                yield session_1.SessionModel.schema(this.ref, "_").bulkCreate([{ sid, session: JSON.stringify(session) }], { updateOnDuplicate: ['session'] });
+            }
+            return { success: 1 };
+        });
+    }
+    getOrderBy(key, { index = null } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let items = [];
+            let { sid, session } = yield this.getSession(index);
+            if (sid) {
+                let data = session[key] || {};
+                items = Object.keys(data).sort((a, b) => data[b] - data[a]).map(k => k);
+            }
+            return { items };
+        });
+    }
+}
+exports.SessionUtil = SessionUtil;

package/utils/setting.d.ts

@@ -0,0 +1,14 @@
+export declare class SettingUtil {
+    private model;
+    ref: string;
+    index: string;
+    constructor(ref: string);
+    getSettingAll(): Promise<{}>;
+    findSetting(keys: Array<string>, {}?: {}): Promise<any>;
+    update(input: any, { attributes, purge }?: {
+        attributes?: any[];
+        purge?: boolean;
+    }): Promise<{
+        success: number;
+    }>;
+}

package/utils/setting.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingUtil = void 0;
+const tslib_1 = require("tslib");
+const sequelize_1 = require("sequelize");
+const setting_1 = require("../models/system/setting");
+const redis_1 = require("../database/redis");
+const _ = require("lodash");
+class SettingUtil {
+    constructor(ref) {
+        this.model = setting_1.SettingModel.getTableName();
+        this.ref = ref;
+        this.index = ref.toLowerCase() + '_' + this.model;
+    }
+    getSettingAll() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return (yield setting_1.SettingModel.schema(this.ref, "_").findAll({
+                raw: true, attributes: ['slug', 'value']
+            })).reduce((total, item) => {
+                total[item['slug']] = item['value'];
+                return total;
+            }, {});
+        });
+    }
+    findSetting(keys, {} = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (redis_1.redisReady) {
+                let setting = yield (0, redis_1.redisGet)(this.index);
+                if (!setting) {
+                    setting = yield this.getSettingAll();
+                    yield (0, redis_1.redisSet)(this.index, JSON.stringify(setting));
+                }
+                else {
+                    setting = JSON.parse(setting);
+                }
+                return _.pick(setting, keys);
+            }
+            return (yield setting_1.SettingModel.schema(this.ref, "_").findAll({
+                raw: true, where: { slug: keys }, attributes: ['slug', 'value']
+            })).reduce((total, item) => {
+                total[item['slug']] = item['value'];
+                return total;
+            }, {});
+        });
+    }
+    update(input, { attributes = [], purge = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let inputs = Object.keys(input).map(slug => ({ slug, value: input[slug] })), replace = false;
+            yield setting_1.SettingModel.schema(this.ref, "_").bulkCreate(inputs, { updateOnDuplicate: ['value'] });
+            if (attributes.length && purge) {
+                replace = true;
+                yield setting_1.SettingModel.schema(this.ref, "_").destroy({
+                    where: { slug: { [sequelize_1.Op.not]: attributes } }
+                });
+            }
+            if (redis_1.redisReady) {
+                let setting = yield (0, redis_1.redisGet)(this.index);
+                if (setting) {
+                    setting = JSON.parse(setting);
+                    setting = Object.assign(Object.assign({}, setting), input);
+                    if (replace)
+                        setting = yield this.getSettingAll();
+                    yield (0, redis_1.redisSet)(this.index, JSON.stringify(setting));
+                }
+            }
+            return { success: 1 };
+        });
+    }
+}
+exports.SettingUtil = SettingUtil;

package/utils/stream.d.ts

@@ -0,0 +1,303 @@
+/// <reference types="qs" />
+import { FileUtil, TagFile } from './file';
+import { QueryParamOption } from '../interface/param';
+import { Request } from 'express';
+import * as Joi from 'joi';
+export declare const getValueFunctionRelationship: (key: any, { field_data }?: {
+    field_data?: {};
+}) => (value: any, { result, ref, lang_code }?: {
+    result?: {};
+    ref?: string;
+    lang_code?: string;
+}) => Promise<void>;
+export declare const getValueFunctionMultiple: (key: any, { field_data }?: {
+    field_data?: {};
+}) => (value: any, { result, ref, lang_code }?: {
+    result?: {};
+    ref?: string;
+    lang_code?: string;
+}) => Promise<void>;
+interface Field {
+    is_required: string | 'yes' | 'no';
+    is_lang: string | 'yes' | 'no';
+    field_name: string;
+    field_type: string | 'text' | 'textarea' | 'wysiwyg' | 'choice' | 'integer' | 'decimal';
+    field_slug?: string;
+    field_data?: any;
+    instructions?: string;
+    [key: string]: any;
+}
+export declare class StreamUtil {
+    ref: string;
+    option: QueryParamOption;
+    folder_parent: string;
+    private initColumn;
+    private builder;
+    private fileUtil;
+    private languageUtil;
+    constructor(ref?: string, option?: QueryParamOption, fileUtil?: FileUtil);
+    findField(slug: string, namespace: string, { index, option, no_lang, field_slug, field_only, field_required, lang, lang_code, is_required, default_value, addition, include, include_only, convert_option, field_option, require, multiple_table, multiple_spread, text, bullets, multiple, relationship, file, image, field_exclude, section }?: {
+        index?: string;
+        option?: {};
+        no_lang?: boolean;
+        field_slug?: any[];
+        field_only?: boolean;
+        field_required?: boolean;
+        lang?: any[];
+        lang_code?: string;
+        is_required?: string;
+        default_value?: any;
+        addition?: {};
+        include?: any;
+        include_only?: boolean;
+        convert_option?: boolean;
+        field_option?: {};
+        require?: boolean;
+        multiple_table?: boolean;
+        multiple_spread?: boolean;
+        text?: boolean;
+        bullets?: boolean;
+        multiple?: boolean;
+        relationship?: boolean;
+        file?: boolean;
+        image?: boolean;
+        field_exclude?: any[];
+        section?: boolean;
+    }): Promise<any>;
+    findFieldStatic(data: any, { field_type, field_exclude, field_slug, include, include_only }?: {
+        field_type?: any[];
+        field_exclude?: any[];
+        field_slug?: any[];
+        include?: any;
+        include_only?: boolean;
+    }): any;
+    buildStream(slug: string, namespace: string, { query, builder, fetch, attribute, attributes, field_exclude, include }?: {
+        query?: boolean;
+        builder?: boolean;
+        fetch?: boolean;
+        attribute?: boolean;
+        attributes?: any;
+        field_exclude?: any[];
+        include?: {};
+    }): Promise<{
+        stream: any;
+        fields: any;
+        fetchFn: any;
+        attributes: any;
+    }>;
+    getBuilder(slug: string, namespace: string, { query, index, builder, field_exclude }?: {
+        query?: boolean;
+        index?: string;
+        builder?: boolean;
+        field_exclude?: any[];
+    }): Promise<any>;
+    getValue(slug: string, namespace: string, value: any, { query, transform, spread, spread_all, raw, lang_code }?: {
+        query?: boolean;
+        transform?: boolean;
+        spread?: boolean;
+        spread_all?: boolean;
+        raw?: boolean;
+        lang_code?: any;
+    }): Promise<{}>;
+    genField(streams: Array<any>, { index, option, slug, id_stream, prefix, multiple_table, multiple_spread, addition, convert_option, field_option, default_value, default_lang, lang_code, no_lang, lang, country, section }?: {
+        index?: string;
+        option?: {};
+        slug?: string;
+        id_stream?: string;
+        prefix?: string;
+        multiple_table?: boolean;
+        multiple_spread?: boolean;
+        addition?: {};
+        convert_option?: boolean;
+        field_option?: {};
+        default_value?: any;
+        default_lang?: string;
+        lang_code?: string;
+        no_lang?: boolean;
+        lang?: any[];
+        country?: any;
+        section?: boolean;
+    }): Promise<any>;
+    getFieldAll(slug: string, namespace: string, { where_field }?: {
+        where_field?: {};
+    }): Promise<any[]>;
+    getDataStreamByField(streams: Array<any>, data: any, { is_lang, option, df_lang }?: {
+        is_lang?: boolean;
+        option?: {};
+        df_lang?: string;
+    }): Promise<any[]>;
+    truncate(slug: string, namespace: string): Promise<true | any[]>;
+    remove(slug: string, namespace: string, index: any, { field, where, error }?: {
+        field?: string;
+        where?: {};
+        error?: boolean;
+    }): Promise<boolean>;
+    upsert(slug: string, namespace: string, input?: any, { id, req, raw_input, attributes, field, where, default_lang, builder }?: {
+        id?: string;
+        req?: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+        raw_input?: {};
+        attributes?: any[];
+        field?: string;
+        where?: {};
+        default_lang?: string;
+        builder?: boolean;
+    }): Promise<any>;
+    upsertBySlug(slug: string, namespace: string, index: string, { ref, req, parent_slug, input, tags, group }?: {
+        ref?: string;
+        req?: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+        parent_slug?: string;
+        input?: {};
+        tags?: TagFile;
+        group?: any;
+    }): Promise<{}>;
+    findStream(slug: string, namespace: string, { result, lang_code, field_exclude, multiple, relationship, file, image, is_lang, stream, use_param }?: {
+        result?: any[];
+        lang_code?: string;
+        field_exclude?: any[];
+        multiple?: boolean;
+        relationship?: boolean;
+        file?: boolean;
+        image?: boolean;
+        is_lang?: boolean;
+        stream?: any;
+        use_param?: boolean;
+    }): Promise<any[]>;
+    cacheIndex(slug: string, namespace: string, { result, field_filter, field_exclude, multiple, relationship, file, image, stream, use_param }?: {
+        result?: any[];
+        field_filter?: any[];
+        field_exclude?: any[];
+        multiple?: boolean;
+        relationship?: boolean;
+        file?: boolean;
+        image?: boolean;
+        stream?: any;
+        use_param?: boolean;
+    }): Promise<Pick<any, any>[]>;
+    createCache(slug: string, namespace: string, { result, lang_code, field_exclude, multiple, single, relationship, file, image, stream, use_param }?: {
+        result?: any[];
+        lang_code?: string;
+        field_exclude?: any[];
+        multiple?: boolean;
+        single?: boolean;
+        relationship?: boolean;
+        file?: boolean;
+        image?: boolean;
+        stream?: any;
+        use_param?: boolean;
+    }): Promise<any[]>;
+    cacheQuery(slug: string, namespace: string, { result, lang_code, single, multiple, relationship }: {
+        result?: any[];
+        lang_code?: string;
+        single?: boolean;
+        multiple?: boolean;
+        relationship?: boolean;
+    }): Promise<any[]>;
+    getStreamFile(slug: string, namespace: string, { includeAttrFile, items, lang_code, field_slug, where, relationship, image, file, single, limit, offset, order, img_kit }?: {
+        includeAttrFile?: any[];
+        items?: any[];
+        lang_code?: string;
+        field_slug?: any[];
+        where?: {};
+        relationship?: boolean;
+        image?: boolean;
+        file?: boolean;
+        single?: boolean;
+        limit?: number;
+        offset?: number;
+        order?: any[];
+        img_kit?: boolean;
+    }): Promise<object>;
+    getInputByLang(input: any, { separate, attributes_i18n, lang }?: {
+        separate?: boolean;
+        attributes_i18n?: any[];
+        lang?: any[];
+    }): Promise<any>;
+    getInputByLangIndex(input: any, { lang }?: {
+        lang?: any[];
+    }): Promise<any[]>;
+    checkStream(slug: string, namespace: string): Promise<number>;
+    addStream(slug: string, namespace: string, input?: any, { stream, column, checkDuplicate, fields, removePrimary }?: {
+        stream?: any;
+        column?: {};
+        checkDuplicate?: boolean;
+        fields?: Field[];
+        removePrimary?: boolean;
+    }): Promise<any>;
+    updateStream(slug: string, namespace: string, input?: any): Promise<[undefined, number] | {
+        [x: string]: any;
+    }>;
+    removeStreamByNamespace(namespace: string): Promise<{
+        success: number;
+    }>;
+    removeStream(slug: string, namespace: string, { stream, error }?: {
+        stream?: {};
+        error?: boolean;
+    }): Promise<boolean>;
+    removeStreamManual(slug: any, { error }?: {
+        error?: boolean;
+    }): Promise<boolean>;
+    addStreamFieldMany(slug: string, namespace: string, fields: Array<Field>, { stream, checkDuplicate }?: {
+        stream?: {};
+        checkDuplicate?: boolean;
+    }): Promise<{
+        success: number;
+    }>;
+    addStreamField(slug: string, namespace: string, field_slug: string, { stream, field, opt, changeTable, checkDuplicate, attributes }?: {
+        stream?: {};
+        field?: Field;
+        opt?: {};
+        changeTable?: boolean;
+        checkDuplicate?: boolean;
+        attributes?: any[];
+    }): Promise<any>;
+    removeStreamFieldMany(slug: string, namespace: string, field_array: Array<any>): Promise<{
+        success: number;
+    }>;
+    removeStreamField(slug: string, namespace: string, field_slug: string, { field_id, stream }?: {
+        field_id?: string;
+        stream?: {};
+    }): Promise<{
+        success: number;
+    }>;
+    inputFieldData(field_type: string, field_data: any): any;
+    getValidator(streams: Array<any>, { schema, input, req, isNew, lang, required, stripUnknown }?: {
+        schema?: {};
+        input?: {};
+        req?: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+        isNew?: boolean;
+        lang?: any[];
+        required?: boolean;
+        stripUnknown?: boolean;
+    }): Promise<Joi.ObjectSchema<any>>;
+    getValidatorSchema(slug: string, namespace: string, { req, isNew, required, lang, stripUnknown, builder }?: {
+        req?: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+        isNew?: boolean;
+        required?: boolean;
+        lang?: any[];
+        stripUnknown?: boolean;
+        builder?: boolean;
+    }): Promise<Joi.ObjectSchema<any>>;
+    validate(slug: string, namespace: string, input: any, { req, isNew, default_value, lang, stripUnknown, inputLang, inputLangSeparate, prefixMessage, builder, field_exclude }?: {
+        req?: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+        isNew?: boolean;
+        default_value?: {};
+        lang?: any[];
+        stripUnknown?: boolean;
+        inputLang?: boolean;
+        inputLangSeparate?: boolean;
+        prefixMessage?: string;
+        builder?: boolean;
+        field_exclude?: any[];
+    }): Promise<any>;
+    validateByField(streams: Array<any>, input: any, { req, isNew, default_value, lang, stripUnknown, inputLang, inputLangSeparate, prefixMessage }?: {
+        req?: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+        isNew?: boolean;
+        default_value?: {};
+        lang?: any[];
+        stripUnknown?: boolean;
+        inputLang?: boolean;
+        inputLangSeparate?: boolean;
+        prefixMessage?: string;
+    }): Promise<any>;
+}
+export {};