@digione/node-custom-api 0.0.1

package/utils/stream.js

@@ -0,0 +1,1893 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamUtil = exports.getValueFunctionMultiple = exports.getValueFunctionRelationship = void 0;
+const tslib_1 = require("tslib");
+const stream_1 = require("../models/stream/stream");
+const field_section_1 = require("../models/stream/field_section");
+const field_1 = require("../models/stream/field");
+const file_1 = require("../models/system/file");
+const file_2 = require("./file");
+const sequelize_1 = require("sequelize");
+const language_1 = require("./language");
+const errors_1 = require("../errors");
+const validator_1 = require("./validator");
+const helper_1 = require("./helper");
+const helper_2 = require("./helper");
+const db_1 = require("./db");
+const user_1 = require("../utils/user");
+const redis_1 = require("../database/redis");
+const database_1 = require("../database");
+const sequelize = require("sequelize");
+const dottie = require("dottie");
+const mime = require("mime-types");
+const i18n_1 = require("i18n");
+const _ = require("lodash");
+const Joi = require("joi");
+const getValueFunctionRelationship = (key, { field_data = {} } = {}) => {
+    return (value, { result = {}, ref = '', lang_code = '' } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        if (value[key] && field_data['table']) {
+            let title_column = field_data['title_column'] || "title";
+            result[key] = yield (0, db_1.findOne)(ref + '_' + field_data['table'], { where: { id: value[key] }, attributes: ['*'] });
+            if (result[key]) {
+                (0, helper_2.getValueFunctionLang)(title_column)(result[key], { result: result[key], lang_code });
+            }
+        }
+    });
+};
+exports.getValueFunctionRelationship = getValueFunctionRelationship;
+const getValueFunctionMultiple = (key, { field_data = {} } = {}) => {
+    return (value, { result = {}, ref = '', lang_code = '' } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        if (field_data['association'] && field_data['table']) {
+            let title_column = field_data['title_column'] || "title";
+            result[key] = yield (0, db_1.findAll)(ref + '_' + field_data['table'], { where: { [`m.row_id`]: { [sequelize_1.Op.eq]: value['id'] } }, attributes: [`${ref + '_' + field_data['table']}.*`], association: [`INNER JOIN ${ref}_${field_data['association']} m ON ${ref + '_' + field_data['table']}.id = m.${field_data['table'] + '_id'}`] });
+            if (result[key] && result[key].length) {
+                result[key] = result[key].map(i => (0, helper_2.getValueByLang)(i, { result: i, field: [title_column], lang_code }));
+            }
+        }
+    });
+};
+exports.getValueFunctionMultiple = getValueFunctionMultiple;
+class StreamUtil {
+    constructor(ref, option, fileUtil) {
+        this.folder_parent = "stream";
+        this.initColumn = {
+            id: {
+                type: sequelize.INTEGER({ length: 11 }),
+                primaryKey: true,
+                autoIncrement: true,
+                allowNull: false
+            },
+            created: {
+                type: sequelize.DATE,
+                allowNull: false
+            },
+            updated: {
+                type: sequelize.DATE
+            },
+            ordering_count: sequelize.INTEGER({ length: 11 }),
+            created_by: {
+                type: sequelize.INTEGER,
+                allowNull: false
+            },
+            organ_id: sequelize.INTEGER
+        };
+        this.builder = {};
+        this.ref = ref;
+        this.option = option || {};
+        this.fileUtil = fileUtil || new file_2.FileUtil(this.ref, this.option);
+        this.languageUtil = new language_1.LanguageUtil(this.ref, this.option);
+    }
+    findField(slug, namespace, { index = "", option = {}, no_lang = false, field_slug = [], field_only = true, field_required = true, lang = [], lang_code = "en", is_required = "", default_value = {}, addition = {}, include = undefined, include_only = false, convert_option = false, field_option = {}, require = false, multiple_table = false, multiple_spread = false, text = false, bullets = false, multiple = false, relationship = false, file = false, image = false, field_exclude = [], section = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let data;
+            let where = {};
+            let field_type = [];
+            if (require) {
+                where['is_required'] = "yes";
+            }
+            if (is_required) {
+                where['is_required'] = is_required;
+            }
+            if (text) {
+                field_type.push('text');
+            }
+            if (bullets) {
+                field_type.push('bullets');
+            }
+            if (file) {
+                field_type.push('file');
+            }
+            if (image) {
+                field_type.push('image');
+            }
+            if (relationship) {
+                field_type.push('relationship');
+            }
+            if (multiple) {
+                field_type.push('multiple');
+            }
+            if (redis_1.redisReady) {
+                let cache = yield redis_1.redisClient.get(this.ref + "_stream_" + namespace + "_" + slug);
+                if (cache) {
+                    data = JSON.parse(cache);
+                    data = yield this.findFieldStatic(data, { field_type, field_exclude, field_slug, include, include_only });
+                }
+            }
+            try {
+                if (!data) {
+                    if (!redis_1.redisReady && field_type.length) {
+                        where['field_type'] = field_type;
+                    }
+                    if (!redis_1.redisReady && field_exclude.length) {
+                        where[sequelize_1.Op.and] = (where[sequelize_1.Op.and] || []).concat({ field_slug: { [sequelize_1.Op.not]: field_exclude } });
+                    }
+                    if (!redis_1.redisReady && field_slug.length) {
+                        where[sequelize_1.Op.and] = (where[sequelize_1.Op.and] || []).concat({ field_slug });
+                    }
+                    if (!redis_1.redisReady && include) {
+                        let group = Object.keys(include), op = !include_only ? [{ group: { [sequelize_1.Op.is]: null } }] : [];
+                        if (group.length) {
+                            op.push({ group });
+                        }
+                        where[sequelize_1.Op.and] = (where[sequelize_1.Op.and] || []).concat({ [sequelize_1.Op.or]: op });
+                    }
+                    let query = yield stream_1.StreamModel.schema(this.ref, '_').findOne({
+                        where: {
+                            stream_slug: slug,
+                            stream_namespace: namespace,
+                        },
+                        include: [
+                            stream_1.StreamAssociation.field.join(this.ref, { where, required: field_required })
+                        ],
+                        order: [[{ model: stream_1.StreamAssociation.field.model, as: stream_1.StreamAssociation.field.alias }, 'sort_order', 'ASC']]
+                    });
+                    if (!query) {
+                        return field_only ? [] : {};
+                    }
+                    data = query.toJSON();
+                    if (redis_1.redisReady) {
+                        yield redis_1.redisClient.set(this.ref + "_stream_" + namespace + "_" + slug, JSON.stringify(data));
+                        data = this.findFieldStatic(data, { field_type, field_exclude, field_slug, include, include_only });
+                    }
+                }
+                if (convert_option) {
+                    data['fields'] = yield this.genField(data['fields'], { index, option, slug, id_stream: data['id'], prefix: data['stream_prefix'], multiple_table, multiple_spread, addition, field_option, default_value, lang_code, no_lang, lang, section });
+                }
+                if (field_only) {
+                    return data['fields'];
+                }
+                return data;
+            }
+            catch (err) {
+                return Promise.reject({ code: 400, message: err.message });
+            }
+        });
+    }
+    findFieldStatic(data, { field_type = [], field_exclude = [], field_slug = [], include = undefined, include_only = false } = {}) {
+        let filter = [];
+        if (field_type.length) {
+            let value = field_type.reduce((total, i) => Object.assign(total, { [i]: 1 }), {});
+            filter.push({ val: (field) => (typeof value[field['field_type']] != "undefined") });
+        }
+        if (field_exclude.length) {
+            let value = field_exclude.reduce((total, i) => Object.assign(total, { [i]: 1 }), {});
+            filter.push({ val: (field) => (typeof value[field['field_slug']] == "undefined") });
+        }
+        if (field_slug.length) {
+            let value = field_slug.reduce((total, i) => Object.assign(total, { [i]: 1 }), {});
+            filter.push({ val: (field) => (typeof value[field['field_slug']] != "undefined") });
+        }
+        if (include) {
+            let con1 = (field) => !field['group'];
+            let con2 = (field) => false;
+            if (include_only)
+                con1 = (field) => false;
+            let group = Object.keys(include);
+            if (group.length) {
+                con2 = (field) => (typeof include[field['group']] != "undefined");
+            }
+            filter.push({ val: (field) => con1(field) || con2(field) });
+        }
+        if (filter.length) {
+            data['fields'] = data['fields'].filter(field => {
+                let bol = true;
+                for (let item of filter) {
+                    if (!item.val(field)) {
+                        bol = false;
+                        continue;
+                    }
+                }
+                return bol;
+            });
+        }
+        return data;
+    }
+    buildStream(slug, namespace, { query = true, builder = true, fetch = false, attribute = false, attributes = null, field_exclude = [], include = {} } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let build = this.builder[slug + "_" + namespace] || { stream: null, fields: null, fetchFn: [], attributes: null };
+            if (!build['fields']) {
+                let data = {};
+                if (query)
+                    data = yield this.findField(slug, namespace, { field_only: false, convert_option: true, field_exclude });
+                build['fields'] = data['fields'] || [];
+                build['stream'] = _.omit(data, ['fields']);
+            }
+            if ((fetch || attribute) && build['fields'].length) {
+                let fetchFn = [];
+                attributes = attributes || {};
+                for (let field of build['fields']) {
+                    let field_data = field['field_data'] || {};
+                    attributes[field['field_slug']] = 1;
+                    if (field_data['date'] && field_data['date']['field_target']) {
+                        delete attributes[field['field_slug']];
+                    }
+                    if (fetch) {
+                        if (field['is_lang'] == "yes") {
+                            fetchFn.push((0, helper_2.getValueFunctionLang)(field['field_slug']));
+                        }
+                        else {
+                            switch (field['field_type']) {
+                                case "file":
+                                case "image":
+                                    include[field['field_slug']] && fetchFn.push((0, helper_2.getValueFunctionFile)(field['field_slug']));
+                                    break;
+                                case "relationship":
+                                case "multiple":
+                                    if (include[field['field_slug']] && field_data['choose_stream']) {
+                                        let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix', 'title_column'] });
+                                        if (stream['stream_slug']) {
+                                            field_data['table'] = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                                            if (field['field_type'] == "relationship") {
+                                                fetchFn.push((0, exports.getValueFunctionRelationship)(field['field_slug'], { field_data }));
+                                            }
+                                            else if (field['field_type'] == "multiple") {
+                                                field_data['association'] = (build['stream']['stream_prefix'] ? build['stream']['stream_prefix'] + build['stream']['stream_slug'] : build['stream']['stream_slug']) + "_" + field_data['table'];
+                                                fetchFn.push((0, exports.getValueFunctionMultiple)(field['field_slug'], { field_data }));
+                                            }
+                                        }
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+                    if (field['field_type'] == "multiple") {
+                        delete attributes[field['field_slug']];
+                    }
+                }
+                build['fetchFn'] = fetchFn;
+            }
+            if (attributes)
+                build['attributes'] = attributes;
+            if (builder)
+                this.builder[slug + "_" + namespace] = build;
+            return build;
+        });
+    }
+    getBuilder(slug, namespace, { query = true, index = "", builder = true, field_exclude = [] } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let result = yield this.buildStream(slug, namespace, { query, builder, field_exclude });
+            return index ? result[index] : result;
+        });
+    }
+    getValue(slug, namespace, value, { query = false, transform = true, spread = false, spread_all = false, raw = false, lang_code = undefined } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let result = {};
+            let fetchFn = yield this.getBuilder(slug, namespace, { query, index: "fetchFn" });
+            lang_code = lang_code || this.option.lang_code;
+            for (let f of fetchFn || []) {
+                yield f(value, { result, ref: this.ref, transform, spread, spread_all, raw, lang_code, fileUtil: this.fileUtil });
+            }
+            return result;
+        });
+    }
+    genField(streams, { index = "", option = {}, slug = "", id_stream = "", prefix = "", multiple_table = false, multiple_spread = false, addition = {}, convert_option = true, field_option = {}, default_value = {}, default_lang = "en", lang_code = "en", no_lang = false, lang = [], country = undefined, section = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let fields = [], sections = [];
+            let exclude = option['excludeObj'] || {};
+            lang_code = option['lang_code'] || lang_code;
+            if (multiple_table) {
+                let result = _.keyBy(default_value, 'lang_code');
+                if (result['undefined'] || !Object.keys(result).length)
+                    multiple_table = false;
+                else
+                    default_value = result;
+            }
+            section = option['section'] || section;
+            if (section && id_stream) {
+                sections = yield field_section_1.FieldSectionModel.schema(this.ref, "_").findAll({
+                    where: { stream_id: id_stream, status: "show" }, attributes: ['id', 'title', 'field_width', 'index'], raw: true,
+                    order: [['ordering_count', 'asc']]
+                });
+                if (sections.length) {
+                    sections = sections.map(i => { (0, helper_2.getValueFunctionLang)('title')(i, { result: i, lang_code }); return i; });
+                }
+            }
+            for (let item of streams) {
+                if (!item || exclude[item['field_slug']]) {
+                    continue;
+                }
+                let field_data = {};
+                if (field_option[item['field_slug']]) {
+                    field_data = field_option[item['field_slug']]['field_data'] || field_data;
+                    item = Object.assign(Object.assign({}, item), field_option[item['field_slug']]);
+                }
+                if (item['field_data']) {
+                    if (typeof item['field_data'] == 'object') {
+                        field_data = item['field_data'];
+                    }
+                    else if (typeof item['field_data'] == 'string') {
+                        try {
+                            field_data = JSON.parse(item['field_data']);
+                        }
+                        catch (err) { }
+                    }
+                }
+                if (typeof field_data['default_value'] !== 'undefined' || field_data['default_color']) {
+                    if (field_data['default_color']) {
+                        field_data['default_value'] = field_data['default_color'];
+                    }
+                    item['field_value'] = item['field_value'] || field_data['default_value'];
+                }
+                if (multiple_table && default_value[lang_code] && typeof default_value[lang_code][item['field_slug']] !== 'undefined') {
+                    item['field_value'] = default_value[lang_code][item['field_slug']];
+                }
+                else if (multiple_spread && typeof default_value[item['field_slug'] + "_" + default_lang] !== 'undefined') {
+                    item['field_value'] = default_value[item['field_slug'] + "_" + default_lang];
+                }
+                else if (typeof default_value[item['field_slug']] !== 'undefined') {
+                    item['field_value'] = default_value[item['field_slug']];
+                }
+                if (item['instructions']) {
+                    (0, helper_2.getValueFunctionLang)('instructions')(item, { result: item, lang_code });
+                }
+                if (item['field_name']) {
+                    (0, helper_2.getValueFunctionLang)('field_name')(item, { result: item, lang_code });
+                }
+                item['field_name_raw'] = item['field_name'] ? item['field_name'] : "";
+                item = Object.assign(Object.assign({}, item), addition);
+                if (convert_option) {
+                    let field_name = String(item['field_name']);
+                    if (field_name.indexOf('lang:') > -1) {
+                        item['field_name'] = (0, i18n_1.__)({ phrase: field_name, locale: lang_code });
+                    }
+                    if (item['instructions']) {
+                        item['instructions'] = (0, i18n_1.__)({ phrase: item['instructions'], locale: lang_code });
+                    }
+                }
+                if (!no_lang && item['is_lang'] && item['is_lang'] == "yes" && !lang.length) {
+                    lang = yield this.languageUtil.getLangsLive();
+                    if (!lang.length)
+                        no_lang = true;
+                }
+                if (no_lang) {
+                    item['is_lang'] = "no";
+                }
+                if (item['is_lang'] && item['is_lang'] == "yes") {
+                    let field_default;
+                    if (multiple_table) {
+                        field_default = lang.length && default_value[lang[0]['lang_code']] ? default_value[lang[0]['lang_code']][item['field_slug']] : null;
+                    }
+                    else if (multiple_spread) {
+                        field_default = lang.length ? default_value[item['field_slug'] + "_" + lang[0]['lang_code']] : null;
+                    }
+                    else {
+                        let value = {};
+                        if (default_value[item['field_slug']])
+                            try {
+                                value = JSON.parse(default_value[item['field_slug']]);
+                            }
+                            catch (err) { }
+                        default_value[item['field_slug']] = value;
+                        field_default = lang.length ? default_value[item['field_slug']][lang[0]['lang_code']] : null;
+                    }
+                    item['data'] = lang.map(i => {
+                        let include = {};
+                        if (multiple_table) {
+                            include['field_value'] = default_value[i['lang_code']] && default_value[i['lang_code']][item['field_slug']];
+                        }
+                        else if (multiple_spread) {
+                            include['field_value'] = default_value[item['field_slug'] + "_" + i['lang_code']];
+                        }
+                        else {
+                            include['field_value'] = default_value[item['field_slug']][i['lang_code']];
+                            item['field_value'] = include['field_value'];
+                        }
+                        include['field_value'] = include['field_value'] || item['field_value'];
+                        if (!include['field_value'] && field_default) {
+                            include['field_value'] = field_default;
+                        }
+                        if (item['instructions']) {
+                            include['instructions'] = item['instructions'];
+                        }
+                        return Object.assign({ field_slug: i['lang_code'], field_name: `${convert_option ? (0, i18n_1.__)({ phrase: item['field_name'], locale: lang_code }) : item['field_name']} (${i['lang_code']})`, field_type: item['field_type'], field_name_raw: item['field_name'] ? item['field_name'] : "", is_required: item['is_required'] }, include);
+                    });
+                    fields.push(Object.assign(Object.assign({}, item), { field_data }));
+                    continue;
+                }
+                if (convert_option) {
+                    if (item['field_type'] == "choice") {
+                        if (field_data['choice_data']) {
+                            let data = [];
+                            data = field_data['choice_data'].split('\n');
+                            _.each(data, (v, k) => {
+                                if (!v) {
+                                    data = data.slice(0, k);
+                                    return;
+                                }
+                                v = v ? v.trim() : "";
+                                if (v.indexOf(':') > -1) {
+                                    let key = v.split(":")[0].trim();
+                                    let value = v.split(/:(.+)/)[1].trim();
+                                    if (value.indexOf('lang:') > -1) {
+                                        value = (0, i18n_1.__)({ phrase: value, locale: lang_code });
+                                    }
+                                    if (key && value) {
+                                        if (key.indexOf('\t') != -1) {
+                                            key = key.replace(/\t/g, '');
+                                        }
+                                        data[k] = { key, value };
+                                    }
+                                    else {
+                                        data[k] = { key: '', value };
+                                    }
+                                }
+                                else {
+                                    data[k] = { key: v, value: v };
+                                }
+                            });
+                            item['data'] = data;
+                        }
+                        else if (item['data']) {
+                            item['data'].map(item => {
+                                let value = item['value'];
+                                if (value && value.indexOf('lang:') > -1) {
+                                    item['value'] = (0, i18n_1.__)({ phrase: value, locale: lang_code });
+                                }
+                                return item;
+                            });
+                        }
+                    }
+                    else if (!field_option[item['field_slug']] && (item['field_type'] == "relationship" || item['field_type'] == "multiple") && field_data['choose_stream']) {
+                        try {
+                            let data = [], where = {}, bol = true;
+                            if (field_data['skip_data'] == "yes") {
+                                if (default_value[item['field_slug']]) {
+                                    where['id'] = default_value[item['field_slug']];
+                                }
+                                bol = (typeof where['id'] != "undefined");
+                            }
+                            if (bol) {
+                                let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix', 'title_column', 'view_options'] });
+                                if (stream && stream['stream_slug']) {
+                                    let view_options = {};
+                                    try {
+                                        view_options = JSON.parse(stream['view_options']);
+                                    }
+                                    catch (err) { }
+                                    if (view_options['params']) {
+                                        let params = String(view_options['params'] || '').split('|').reduce((total, key) => {
+                                            return option[key] ? Object.assign(total, { [key]: option[key] }) : total;
+                                        }, {});
+                                        where = Object.assign(where, params);
+                                    }
+                                    if (index && slug && item['field_type'] == "multiple") {
+                                        let table = prefix ? prefix + slug : slug;
+                                        let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                                        try {
+                                            let query = yield (0, db_1.findAll)(`${this.ref}_${table}_${table_f}`, { where: { row_id: index }, attributes: [`${[table_f + "_id"]}`] });
+                                            item['field_value'] = query ? query.map(i => i[table_f + "_id"]).join(',') : '';
+                                        }
+                                        catch (err) { }
+                                    }
+                                    let table = stream['stream_slug'];
+                                    if (stream['stream_prefix']) {
+                                        table = stream['stream_prefix'] + stream['stream_slug'];
+                                    }
+                                    table = `${this.ref}_${table}`;
+                                    let query = yield (0, db_1.findAll)(table, { where });
+                                    if (query && query.length) {
+                                        query = query.map(item => {
+                                            item['title'] = item['title'] ? item['title'] : item[stream['title_column']];
+                                            (0, helper_2.getValueFunctionLang)('title')(item, { result: item, lang_code });
+                                            let value = item['title'] ? item['title'] : item['id'];
+                                            return {
+                                                key: item['id'],
+                                                value
+                                            };
+                                        });
+                                    }
+                                    data = query;
+                                }
+                            }
+                            item['data'] = data;
+                        }
+                        catch (err) { }
+                    }
+                    else if (item['field_type'] == "pyro_lang") {
+                        item['data'] = [
+                            { key: 'en', value: "English" },
+                            { key: 'th', value: "Thailand" }
+                        ];
+                    }
+                    else if (item['field_type'] == "image" || item['field_type'] == "file") {
+                        if (item['field_value']) {
+                            if (!/\./.test(item['field_value'])) {
+                                item['data'] = yield this.fileUtil.findOneFileById(item['field_value']);
+                            }
+                            else {
+                                item['data'] = { path: item['field_value'] };
+                            }
+                        }
+                    }
+                    else if (item['field_type'] == "datetime") {
+                        if (typeof field_data['start_date'] != "undefined" && (0, helper_1.isNumber)(field_data['start_date'], { negative: true })) {
+                            field_data['start_date'] = field_data['start_date'] + "Y";
+                        }
+                        if (typeof field_data['end_date'] != "undefined" && (0, helper_1.isNumber)(field_data['end_date'], { negative: true })) {
+                            field_data['end_date'] = field_data['end_date'] + "Y";
+                        }
+                        if (field_data['range'] && field_data['range']['field_target']) {
+                            field_data['range']['field_value'] = default_value[field_data['range']['field_target']];
+                        }
+                    }
+                    else if (item['field_type'] == "time") {
+                        if (field_data['date'] && field_data['date']['field_target']) {
+                            item['field_value'] = default_value[field_data['date']['field_target']] || item['field_value'];
+                        }
+                    }
+                    else if (item['field_type'] == "encrypt") {
+                        if (item['field_value']) {
+                            if (item['field_value'] instanceof Buffer)
+                                item['field_value'] = item['field_value'].toString();
+                            item['field_value'] = (0, helper_1.xorDecode)(item['field_value']);
+                        }
+                        if (field_data['hide_typing'] == "yes") {
+                            item['field_type'] = "password";
+                        }
+                        else {
+                            item['field_type'] = "text";
+                            field_data['hide_typing'] = "no";
+                        }
+                        field_data['field_type'] = 'encrypt';
+                    }
+                    else if (item['field_type'] == "phone") {
+                        if (!country)
+                            country = yield (0, user_1.getCountry)(this.ref, { organ_id: this.option.organ_id, lang_code });
+                        if (country && country['data']) {
+                            item['data'] = country['data'];
+                        }
+                        if (field_data['code'] && field_data['code']['field_target']) {
+                            if (country && country['default_country']) {
+                                field_data['code']['field_value'] = country['default_country']['key'];
+                            }
+                            field_data['code']['field_value'] = default_value[field_data['code']['field_target']] || field_data['code']['field_value'];
+                        }
+                    }
+                }
+                fields.push(Object.assign(Object.assign({}, item), { field_data }));
+            }
+            ;
+            fields = _.orderBy(fields, ['sort_order', 'field_id'], ['asc', 'asc']);
+            if (section) {
+                return { sections, fields };
+            }
+            return fields;
+        });
+    }
+    getFieldAll(slug, namespace, { where_field = {} } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let results = [];
+            let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({
+                raw: true, where: { stream_slug: slug, stream_namespace: namespace }, attributes: ['id']
+            });
+            if (stream) {
+                let fields = yield field_1.FieldModel.schema(this.ref, "_").findAll({
+                    raw: true, where: Object.assign(Object.assign({}, where_field), { stream_id: stream['id'] }), attributes: ['field_slug']
+                });
+                if (fields.length) {
+                    results = fields.map(i => i['field_slug']);
+                }
+            }
+            return results;
+        });
+    }
+    getDataStreamByField(streams, data, { is_lang = false, option = {}, df_lang = "en" } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let fields = [];
+            let exclude = option['excludeObj'] || {};
+            if (is_lang) {
+                let result = _.keyBy(data, 'lang_code');
+                for (let i of streams) {
+                    if (!i || exclude[i['field_slug']])
+                        continue;
+                    try {
+                        if (i['is_lang'] && i['is_lang'] == "yes" && i['data'] && i['data'].length) {
+                            i['data'] = i['data'].map(d => {
+                                if (result[d['field_slug']]) {
+                                    d['field_value'] = result[d['field_slug']][i['field_slug']];
+                                }
+                                return d;
+                            });
+                        }
+                        else {
+                            if (i['field_type'] == 'multiple') {
+                                fields.push(i);
+                                continue;
+                            }
+                            i['field_value'] = result[df_lang][i['field_slug']] ? result[df_lang][i['field_slug']] : i['field_value'];
+                        }
+                    }
+                    catch (err) { }
+                    fields.push(i);
+                }
+            }
+            else {
+                for (let i of streams) {
+                    if (!i || exclude[i['field_slug']])
+                        continue;
+                    try {
+                        if (i['is_lang'] && i['is_lang'] == "yes" && i['data'] && i['data'].length) {
+                            i['data'] = i['data'].map(d => {
+                                if (data[i['field_slug'] + "_" + d['field_slug']]) {
+                                    d['field_value'] = data[i['field_slug'] + "_" + d['field_slug']];
+                                }
+                                return d;
+                            });
+                        }
+                        else {
+                            let field_data = null;
+                            if (i['field_data']) {
+                                if (typeof i['field_data'] == 'object') {
+                                    field_data = i['field_data'];
+                                }
+                                else if (typeof i['field_data'] == 'string') {
+                                    try {
+                                        field_data = JSON.parse(i['field_data']);
+                                    }
+                                    catch (err) { }
+                                }
+                            }
+                            if (field_data && field_data['default_value'] && !data[i['field_slug']]) {
+                                i['field_value'] = field_data['default_value'];
+                            }
+                            i['field_value'] = data[i['field_slug']] ? data[i['field_slug']] : i['field_value'];
+                        }
+                    }
+                    catch (err) { }
+                    fields.push(i);
+                }
+            }
+            return fields;
+        });
+    }
+    truncate(slug, namespace) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let { id: id_stream, stream_prefix, fields: streams } = yield this.findField(slug, namespace, { field_only: false, multiple: true, convert_option: true });
+            let table = stream_prefix ? stream_prefix + slug : slug;
+            if (id_stream && (streams && streams.length)) {
+                return yield Promise.all(streams.map(({ field_data }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                    let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                    return yield (0, db_1.truncate)(`${this.ref}_${table}_${table_f}`);
+                })));
+            }
+            return true;
+        });
+    }
+    remove(slug, namespace, index, { field = "id", where = {}, error = true } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let { id: id_stream, stream_prefix, fields: streams } = yield this.findField(slug, namespace, { field_only: false, field_required: false, convert_option: true });
+            let table = stream_prefix ? stream_prefix + slug : slug;
+            where = Object.assign(Object.assign({}, where), { [field]: index });
+            let query = yield (0, db_1.findAll)(`${this.ref}_${table}`, { where });
+            if (query.length) {
+                let id = query.map(i => i['id']);
+                if (id_stream && (streams && streams.length)) {
+                    let file_id = [];
+                    yield Promise.all(streams.map(({ field_type, field_slug, field_data }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        if (field_type == "multiple" && field_data && field_data['choose_stream']) {
+                            let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                            let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                            yield (0, db_1.remove)(this.ref, `${table}_${table_f}`, { where: { row_id: id } });
+                        }
+                        else if ((field_type == "file" || field_type == "image")) {
+                            file_id = file_id.concat(query.reduce((total, item) => item[field_slug] ? total.concat(item[field_slug]) : total, []));
+                        }
+                    })));
+                    if (file_id.length) {
+                        yield this.fileUtil.removeFileById(file_id, { error: false });
+                    }
+                }
+                yield (0, db_1.remove)(this.ref, table, { where });
+            }
+            else if (error) {
+                return Promise.reject(errors_1.generalError.NOT_FOUND);
+            }
+            return true;
+        });
+    }
+    upsert(slug, namespace, input = {}, { id = "", req = {}, raw_input = {}, attributes = [], field = "id", where = {}, default_lang = "en", builder = true } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let files = {}, id_files = {};
+            let lang_code = input['lang_code'] ? input['lang_code'] : default_lang;
+            let isNew = id ? false : true, query;
+            let { stream, fields } = yield this.getBuilder(slug, namespace, { builder });
+            stream = stream || {};
+            let id_stream = stream['id'], stream_prefix = stream['stream_prefix'];
+            if (fields && fields.length) {
+                fields = fields.filter(({ is_lang, field_type, field_data }) => field_type && (is_lang == "yes" || (field_type == "multiple" && field_data['self_table'] != "yes") || field_type == "image" || field_type == "file" || field_data['field_type'] == "encrypt"));
+            }
+            if (!Object.keys(raw_input).length) {
+                raw_input = input;
+            }
+            let table = stream_prefix ? stream_prefix + slug : slug;
+            let except = fields ? fields.map(i => i['field_slug']) : [];
+            if (!attributes.length) {
+                attributes = yield (0, db_1.getFieldAll)(this.ref + "_" + table);
+            }
+            let data = _.pick(_.omit(input, except), attributes);
+            if (!Object.keys(data).length) {
+                return Promise.reject(errors_1.generalError.BAD_REQUEST);
+            }
+            if (req.files) {
+                files = _.reduce(req.files, (total, item) => {
+                    total[item['fieldname']] = item;
+                    return total;
+                }, {});
+            }
+            if (fields && fields.length) {
+                let attributes = fields.reduce((total, { field_type, field_slug }) => {
+                    if ((field_type == "file" || field_type == "image"))
+                        total.push(field_slug);
+                    return total;
+                }, []);
+                if (attributes.length) {
+                    let query = yield (0, db_1.findOne)(`${this.ref}_${table}`, { where: Object.assign(Object.assign({}, where), { [field]: id }), attributes });
+                    if (query)
+                        id_files = query;
+                }
+            }
+            let fields_post = [];
+            if (id_stream && fields.length) {
+                yield Promise.all(fields.map(({ id: field_id, is_lang, field_type, field_slug, field_data }, index) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    if (is_lang == "yes" && input[field_slug]) {
+                        data[field_slug] = JSON.stringify(input[field_slug]);
+                    }
+                    else if ((field_type == "file" || field_type == "image")) {
+                        if (files[field_slug] && field_data) {
+                            let validate = false;
+                            if (id && id_files[field_slug]) {
+                                yield this.fileUtil.removeFileById(id_files[field_slug], { error: false });
+                            }
+                            if (!field_data['allowed_types'] || field_data['allowed_types'] == "*") {
+                                validate = true;
+                            }
+                            else {
+                                let allowed_types = (field_data['allowed_types']).split("|");
+                                if (allowed_types.find(i => files[field_slug]['originalname'].indexOf(i) > -1)) {
+                                    validate = true;
+                                }
+                            }
+                            if (validate) {
+                                try {
+                                    let folder_slug = 'field_' + field_id;
+                                    let req = { file: files[field_slug] };
+                                    let res = yield this.fileUtil.uploadByReq(req, folder_slug, this.option.auth_id || 1, { parent_slug: this.folder_parent });
+                                    if (res && res[0] && res[0]['id']) {
+                                        data[field_slug] = res[0]['id'];
+                                    }
+                                }
+                                catch (err) { }
+                            }
+                        }
+                        else if (raw_input[field_slug]) {
+                            data[field_slug] = raw_input[field_slug];
+                        }
+                        else if ((raw_input[field_slug] === null || raw_input[field_slug] === "")) {
+                            if (id_files[field_slug])
+                                yield this.fileUtil.removeFileById(id_files[field_slug], { error: false });
+                            data[field_slug] = null;
+                        }
+                    }
+                    else if (field_data['field_type'] == "encrypt" && raw_input[field_slug]) {
+                        data[field_slug] = (0, helper_1.xorEncode)(raw_input[field_slug]);
+                    }
+                    else if (field_type == "multiple") {
+                        fields_post.push(fields[index]);
+                    }
+                })));
+            }
+            if (id) {
+                yield (0, db_1.update)(this.ref, table, data, { where, default_lang });
+                query = { id };
+            }
+            else {
+                query = yield (0, db_1.insert)(this.ref, table, data);
+                id = query['id'];
+            }
+            if (!id_stream || (fields && !fields.length)) {
+                return query;
+            }
+            if (id_stream) {
+                yield Promise.all(fields_post.map(({ field_type, field_slug, field_data }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    if (field_type == "multiple" && lang_code == default_lang && field_data && field_data['choose_stream']) {
+                        let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                        let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                        if (!isNew) {
+                            yield (0, db_1.remove)(this.ref, `${table}_${table_f}`, { where: { row_id: id } });
+                        }
+                        if (raw_input[field_slug]) {
+                            let op = [];
+                            try {
+                                op = raw_input[field_slug].split(',');
+                            }
+                            catch (err) { }
+                            yield Promise.all(op.map((v) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                                v = String(v).replace(/[^0-9]/g, '');
+                                if (!v)
+                                    return 1;
+                                let input = { row_id: id, [slug + "_id"]: id, [table_f + "_id"]: v };
+                                yield (0, db_1.insert)(this.ref, `${table}_${table_f}`, input);
+                            })));
+                        }
+                    }
+                    return raw_input[field_slug];
+                })));
+                return query;
+            }
+            return Promise.reject(errors_1.generalError.BAD_REQUEST);
+        });
+    }
+    upsertBySlug(slug, namespace, index, { ref = "", req = {}, parent_slug = "", input = {}, tags = [], group = undefined } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let fields = yield this.getBuilder(slug, namespace, { index: "fields" }), where_folder = {};
+            ref = ref || this.ref;
+            let files = (req.file ? [req.file] : (req.files || [])).reduce((total, item) => Object.assign(total, { [item['fieldname']]: item }), {});
+            let id_files = {}, fileUtil = new file_2.FileUtil(ref, this.option);
+            if (parent_slug) {
+                let query = yield fileUtil.createFolder(parent_slug, { root: true, parent_id: where_folder['parent_id'] });
+                if (query)
+                    where_folder['parent_id'] = query['id'];
+            }
+            let folder = yield fileUtil.createFolder(index, { parent_id: where_folder['parent_id'] });
+            let where_file = { folder_id: folder['id'], is_hidden: "yes" };
+            where_file = fileUtil.beforeFindFile(where_file, { tags, group });
+            let query = yield file_1.FileModel.schema(ref, "_").findAll({ where: where_file, attributes: ['id', 'name'], raw: true });
+            id_files = query.reduce((total, item) => Object.assign(total, { [item['name']]: item['id'] }), {});
+            let input_files = [];
+            yield Promise.all(fields.map(({ field_type, field_slug, field_data }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                if ((field_type == "file" || field_type == "image")) {
+                    if (files[field_slug] && field_data) {
+                        if (id_files[field_slug]) {
+                            yield fileUtil.removeFileById(id_files[field_slug], { error: false });
+                        }
+                        try {
+                            let req = { file: files[field_slug] };
+                            req['file']['originalname'] = field_slug;
+                            let res = yield fileUtil.uploadByReq(req, index, this.option.auth_id || 1, { parent_slug, is_hidden: "yes", tags, group });
+                            if (res && res[0] && res[0]['id']) {
+                                input_files.push(res[0]['id']);
+                            }
+                        }
+                        catch (err) {
+                            input[field_slug] = null;
+                        }
+                    }
+                    else if ((input[field_slug] === null || input[field_slug] === "")) {
+                        if (id_files[field_slug])
+                            yield fileUtil.removeFileById(id_files[field_slug], { error: false });
+                        input[field_slug] = null;
+                    }
+                    else if (id_files[field_slug]) {
+                        input_files.push(id_files[field_slug]);
+                    }
+                }
+            })));
+            if (input_files.length) {
+                let query = yield fileUtil.findAllFile({ full: true, where: { id: input_files, is_hidden: "yes" }, attributes: ['name', 'filename', 'path'] });
+                let attribute = query.reduce((total, item) => Object.assign(total, { [item['name']]: item['path'] }), {});
+                input = Object.assign(Object.assign({}, input), attribute);
+            }
+            return input;
+        });
+    }
+    findStream(slug, namespace, { result = [], lang_code = "en", field_exclude = [], multiple = true, relationship = true, file = true, image = true, is_lang = true, stream = {}, use_param = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!use_param) {
+                stream = yield this.findField(slug, namespace, { field_exclude, field_only: false, multiple, relationship, file, image, convert_option: true });
+            }
+            let { id: id_stream, stream_prefix, fields: streams } = stream;
+            let table = stream_prefix ? stream_prefix + slug : slug;
+            if (id_stream && result.length) {
+                yield Promise.all(streams.map(({ field_type, field_slug, field_data }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield Promise.all(result.map((data) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        if (field_type == "file" || field_type == "image") {
+                            if (data[field_slug]) {
+                                data[field_slug] = yield this.fileUtil.findOneFileById(data[field_slug]);
+                            }
+                        }
+                        else if (field_type == "relationship" && field_data) {
+                            if (data[field_slug]) {
+                                let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                                let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                                data[field_slug] = yield (0, db_1.findOne)(`${this.ref}_${table_f}`, { where: { id: data[field_slug] } });
+                            }
+                        }
+                        else if (field_type == "multiple" && field_data) {
+                            let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                            let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                            let join = yield (0, db_1.findAll)(`${this.ref}_${table}_${table_f}`, { where: { row_id: data['id'] }, attributes: [`${table_f + "_id"}`] });
+                            if (join && join.length) {
+                                let where = join.map(i => i[table_f + "_id"]).join(',');
+                                let lang_code_exist;
+                                if (yield (0, db_1.getExistField)(this.ref + "_" + table_f, 'lang_code')) {
+                                    lang_code_exist = true;
+                                    lang_code = data['lang_code'] ? data['lang_code'] : lang_code;
+                                }
+                                let query = yield database_1.default.query(`SELECT * FROM ${this.ref}_${table_f} WHERE id IN (${where}) ${lang_code_exist ? `AND lang_code='${lang_code}'` : ''}`);
+                                data[field_slug] = query && query.length ? query[0] : [];
+                            }
+                            else {
+                                data[field_slug] = [];
+                            }
+                        }
+                    })));
+                })));
+            }
+            return result;
+        });
+    }
+    cacheIndex(slug, namespace, { result = [], field_filter = [], field_exclude = [], multiple = true, relationship = true, file = true, image = true, stream = {}, use_param = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!use_param) {
+                stream = yield this.findField(slug, namespace, { field_exclude, field_only: false, multiple, relationship, file, image, convert_option: true });
+            }
+            let { id: id_stream, stream_prefix, fields: streams } = stream;
+            if (id_stream) {
+                result = _.cloneDeep(result);
+                let table = stream_prefix ? stream_prefix + slug : slug;
+                yield Promise.all(streams.map(({ field_type, field_slug, field_data }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    if (field_type == "relationship" || field_type == "multiple") {
+                        field_filter.push(field_slug);
+                    }
+                    yield Promise.all(result.map((data) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        if (multiple && field_type == "multiple" && field_data) {
+                            let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                            let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                            let join = yield (0, db_1.findAll)(`${this.ref}_${table}_${table_f}`, { where: { row_id: data['id'] }, attributes: [`${table_f + "_id"}`] });
+                            join = join.map(i => i[table_f + "_id"]);
+                            data[field_slug] = join;
+                        }
+                    })));
+                })));
+            }
+            return result.map(i => _.pick(i, field_filter));
+        });
+    }
+    createCache(slug, namespace, { result = [], lang_code = "en", field_exclude = [], multiple = true, single = false, relationship = true, file = true, image = true, stream = {}, use_param = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!use_param) {
+                stream = yield this.findField(slug, namespace, { field_exclude, field_only: false, multiple, relationship, file, image, convert_option: true });
+            }
+            if (!single) {
+                multiple = false;
+                relationship = false;
+            }
+            let { id: id_stream, stream_prefix, fields: streams } = stream;
+            if (id_stream) {
+                result = _.cloneDeep(result);
+                let table = stream_prefix ? stream_prefix + slug : slug;
+                let ref = this.ref.toLowerCase();
+                let index = ref + "_" + table;
+                let multi = redis_1.redisClient.multi();
+                yield Promise.all(streams.map(({ field_type, field_slug, field_data }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    yield Promise.all(result.map((data) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        data['stream'] = data['stream'] ? data['stream'] : {};
+                        if (file && data[field_slug] && (field_type == "file" || field_type == "image")) {
+                            data['stream'][field_slug] = { type: field_type, value: data[field_slug] };
+                        }
+                        else if (relationship && field_type == "relationship" && field_data) {
+                            if (data[field_slug] && data[field_slug]['id']) {
+                                let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                                let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                                let is_lang = false;
+                                let key = "data";
+                                if (data[field_slug]['lang_code']) {
+                                    is_lang = true;
+                                    key = key + "_" + data[field_slug]['lang_code'];
+                                }
+                                multi.hset(ref + "_" + table_f + "_" + data[field_slug]['id'], key, JSON.stringify(data[field_slug]));
+                                data['stream'][field_slug] = { type: field_type, is_lang, table: table_f, value: data[field_slug]['id'] };
+                            }
+                        }
+                        else if (multiple && field_type == "multiple" && field_data) {
+                            if (data[field_slug] && data[field_slug].length) {
+                                let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                                let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                                let is_lang = false;
+                                data[field_slug].forEach(i => {
+                                    let key = "data";
+                                    if (i['lang_code']) {
+                                        is_lang = true;
+                                        key = key + "_" + i['lang_code'];
+                                    }
+                                    multi.hset(ref + "_" + table_f + "_" + i['id'], key, JSON.stringify(i));
+                                });
+                                data['stream'][field_slug] = { type: field_type, is_lang, table: table_f, value: data[field_slug].map(i => i['id']).join(',') };
+                            }
+                        }
+                        delete data[field_slug];
+                    })));
+                })));
+                let obj = {};
+                result.forEach(i => {
+                    if (i['id'] && !obj[i['id']] && _.size(i['stream'])) {
+                        obj[i['id']] = true;
+                        multi.hset(index + "_" + i['id'], "stream", JSON.stringify(i['stream']));
+                    }
+                    delete i['stream'];
+                });
+                yield multi.exec();
+            }
+            return result;
+        });
+    }
+    cacheQuery(slug, namespace, { result = [], lang_code = "en", single = false, multiple = true, relationship = true }) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!single) {
+                multiple = false;
+                relationship = false;
+            }
+            let arr = {};
+            let ref = this.ref.toLowerCase();
+            result = result.map((i) => {
+                if (i['stream'] && _.size(i['stream'])) {
+                    _.map(i['stream'], ((v, k) => {
+                        if (multiple && v['type'] == "multiple") {
+                            let value = v['value'].split(',');
+                            if (arr[k]) {
+                                arr[k]['value'] = arr[k]['value'].concat(value);
+                            }
+                            else {
+                                v['value'] = value;
+                                arr[k] = v;
+                            }
+                            i[k] = value;
+                        }
+                        else if (relationship && v['type'] == "relationship") {
+                            arr[k] = v['value'];
+                            i[k] = v['value'];
+                        }
+                        else {
+                            i[k] = v['value'];
+                        }
+                    }));
+                }
+                delete i['stream'];
+                return i;
+            });
+            yield Promise.all(_.map(arr, (v, k) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                if (v) {
+                    let value = _.uniq(v['value']);
+                    let multi = redis_1.redisClient.multi();
+                    let key = "data";
+                    if (v['is_lang']) {
+                        key = key + "_" + lang_code;
+                    }
+                    value.forEach(index => {
+                        multi.hget(ref + "_" + v['table'] + "_" + index, key);
+                    });
+                    value = yield (0, helper_1.multiExecArray)(multi, { json_parse: true });
+                    let obj = _.keyBy(value, 'id');
+                    result = result.map(item => {
+                        return Object.assign(Object.assign({}, item), { [k]: item[k] && typeof item[k] == "object" ? item[k].map(val => obj[val]) : obj[item[k]] });
+                    });
+                }
+            })));
+            return result;
+        });
+    }
+    getStreamFile(slug, namespace, { includeAttrFile = [], items = [], lang_code = "en", field_slug = [], where = {}, relationship = true, image = true, file = false, single = false, limit = 10, offset = 0, order = [], img_kit = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (single) {
+                limit = 1;
+            }
+            let sql;
+            let type = {};
+            let include = [];
+            if (!items.length) {
+                relationship = false;
+            }
+            type['image'] = image;
+            type['file'] = file;
+            type['relationship'] = relationship;
+            let { stream_prefix, fields: field } = yield this.findField(slug, namespace, Object.assign(Object.assign({}, type), { field_only: false, field_slug, convert_option: true }));
+            let table = stream_prefix ? stream_prefix + slug : slug;
+            if (field && field.length) {
+                const p = this.ref + "_" + table;
+                const f = this.ref + "_" + file_1.FileModel.getTableName();
+                const attributes = ['id', 'filename', 'path', 'width', 'height'].concat(includeAttrFile);
+                let limitSql, offsetSql, orderSql = "", whereSql = (0, db_1.genWhere)(where, { as: "p" });
+                if (order.length) {
+                    order = order[0];
+                    orderSql = `ORDER BY p.${order[0]} ${order[1]}`;
+                }
+                limitSql = limit ? `LIMIT ${limit}` : "";
+                offsetSql = offset ? `OFFSET ${offset}` : "";
+                if (relationship && items.length) {
+                    let relation = [];
+                    relation = yield Promise.all(_.map(field, (fi, index) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        if (fi['field_type'] == "relationship") {
+                            try {
+                                let lang_code;
+                                let field_data = fi['field_data'];
+                                let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                                let table_f = stream['stream_slug'];
+                                if (stream['stream_prefix']) {
+                                    table_f = stream['stream_prefix'] + stream['stream_slug'];
+                                }
+                                table_f = `${this.ref}_${table_f}`;
+                                if (yield (0, db_1.getExistField)(table_f, 'lang_code')) {
+                                    lang_code = true;
+                                }
+                                else {
+                                    lang_code = false;
+                                }
+                                return Object.assign(Object.assign({}, fi), { table: table_f, lang_code });
+                            }
+                            catch (err) {
+                                return null;
+                            }
+                        }
+                        return null;
+                    })));
+                    if (relation.length) {
+                        relation = _.compact(relation);
+                        include = yield Promise.all(_.map(items, (item, index) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                            let obj = {};
+                            yield Promise.all(_.map(relation, (re) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                                try {
+                                    if (re['lang_code']) {
+                                        obj[re['field_slug']] = yield (0, db_1.findOne)(re['table'], { where: { id: item[re['field_slug']], lang_code } });
+                                    }
+                                    else {
+                                        obj[re['field_slug']] = yield (0, db_1.findOne)(re['table'], { where: { id: item[re['field_slug']] } });
+                                    }
+                                }
+                                catch (err) { }
+                            })));
+                            return obj;
+                        })));
+                    }
+                }
+                field = _.filter(field, (item) => item['field_type'] != "relationship");
+                if (field.length) {
+                    sql = `
+                    SELECT
+                        ` + _.map(field, (stream, index) => {
+                        if (stream['field_type'] != "relationship") {
+                            return _.map(attributes, (a) => {
+                                return `f${index}.${a} AS '${stream['field_slug']}.${a}'`;
+                            });
+                        }
+                        return null;
+                    }).filter(i => i != null).join(",") + `
+                
+                    FROM ${p} as p
+                    ` + _.map(field, (stream, index) => {
+                        if (stream['field_type'] != "relationship") {
+                            return `LEFT OUTER JOIN ${f} f${index} ON p.${stream['field_slug']} = f${index}.id `;
+                        }
+                        return null;
+                    }).join("") + `
+                    ${whereSql} 
+                    ${orderSql}
+                    ${limitSql}
+                    ${offsetSql}
+                `;
+                }
+                try {
+                    if (!sql) {
+                        return null;
+                    }
+                    let query = yield database_1.default.query(sql, { type: sequelize_1.QueryTypes.SELECT });
+                    if (query && query.length) {
+                        let setting = {};
+                        if (img_kit) {
+                            setting = yield this.fileUtil.getSettingImgKit();
+                        }
+                        query = query.map((item) => {
+                            let data = dottie.transform(item);
+                            Object.keys(data).forEach((key) => {
+                                data[key] = this.fileUtil.afterQueryFile(data[key]);
+                                if (setting["url"] && data[key]["path"]) {
+                                    data[key]["path"] = this.fileUtil.convertImgKit(data[key]["path"], setting);
+                                }
+                                if (!data[key]["id"])
+                                    data[key] = null;
+                            });
+                            return data;
+                        });
+                        if (query.length) {
+                            query = _.merge(query, include);
+                        }
+                        else if (include.length) {
+                            query = include;
+                        }
+                        if (single) {
+                            return query[0];
+                        }
+                        return query;
+                    }
+                }
+                catch (err) { }
+            }
+            return null;
+        });
+    }
+    getInputByLang(input, { separate = false, attributes_i18n = [], lang = [] } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let input_lang = {};
+            let items = [];
+            _.each(input, (item, key) => {
+                if (_.isObject(item)) {
+                    input_lang[key] = item;
+                    delete input[key];
+                }
+            });
+            _.each(input, (value, key) => {
+                if (value === "") {
+                    input[key] = null;
+                }
+            });
+            if (!lang.length) {
+                lang = yield this.languageUtil.getLangsLive();
+            }
+            if (lang.length) {
+                if (separate) {
+                    lang.forEach((language, key) => {
+                        _.each(input_lang, (v, k) => input[k + "_" + language['lang_code']] = v[language['lang_code']] || v['en']);
+                    });
+                    return input;
+                }
+                items = lang.map((language, key) => {
+                    let item_lang = {};
+                    _.each(input_lang, (v, k) => item_lang[k] = v[language['lang_code']] || v['en']);
+                    let item = Object.assign(Object.assign({}, item_lang), input);
+                    item['lang_code'] = language['lang_code'];
+                    return item;
+                });
+            }
+            if (attributes_i18n.length) {
+                let input = _.omit(items[0], [...attributes_i18n, 'lang_code']);
+                items = items.map(item => {
+                    return Object.assign(Object.assign({}, _.pick(item, attributes_i18n)), { lang_code: item['lang_code'] });
+                });
+                items = { input, i18n: items };
+            }
+            return items;
+        });
+    }
+    getInputByLangIndex(input, { lang = [] } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let input_lang = {};
+            let items = [];
+            _.each(input, (item, key) => {
+                if (_.isArray(item)) {
+                    input_lang[key] = item;
+                    delete input[key];
+                }
+            });
+            _.each(input, (value, key) => {
+                if (!value) {
+                    delete input[key];
+                }
+            });
+            if (!lang.length) {
+                lang = yield this.languageUtil.getLangsLive();
+            }
+            if (lang.length) {
+                items = yield Promise.all(lang.map((language, key) => {
+                    let item_lang = {};
+                    _.each(input_lang, (v, k) => item_lang[k] = v[key]);
+                    let item = Object.assign(Object.assign({}, item_lang), input);
+                    item['lang_code'] = language['lang_code'];
+                    return item;
+                }));
+            }
+            return items;
+        });
+    }
+    checkStream(slug, namespace) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield stream_1.StreamModel.schema(this.ref, "_").count({ where: { stream_slug: slug, stream_namespace: namespace } });
+        });
+    }
+    addStream(slug, namespace, input = {}, { stream = undefined, column = {}, checkDuplicate = true, fields = [], removePrimary = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            input['stream_slug'] = slug;
+            input['stream_namespace'] = namespace;
+            if (checkDuplicate && !stream) {
+                stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { stream_slug: input['stream_slug'], stream_namespace: input['stream_namespace'] }, attributes: ['id', 'stream_type'], raw: true });
+            }
+            let table = input['stream_prefix'] ? input['stream_prefix'] + input['stream_slug'] : input['stream_slug'];
+            let exist = yield (0, db_1.getExistTable)(`${this.ref}_${table}`);
+            if (checkDuplicate && (stream || exist)) {
+                return Promise.reject(errors_1.generalError.SLUG_DUPLICATE);
+            }
+            input['stream_type'] = input['stream_type'] || (stream || {})['stream_type'] || "auto";
+            if (!stream) {
+                if (!input['view_options'] || !input['view_options']['column']) {
+                    input['view_options'] = input['view_options'] || {};
+                    input['view_options']['column'] = { column: "id|created" };
+                }
+                if (!input['stream_name']) {
+                    input['stream_name'] = _.startCase(_.camelCase(input['stream_slug']));
+                }
+                input['view_options'] = input['view_options'] ? JSON.stringify(input['view_options']) : null;
+                stream = yield (0, db_1.insert)(this.ref, stream_1.StreamModel.getTableName().toString(), input);
+            }
+            else {
+                yield (0, db_1.update)(this.ref, stream_1.StreamModel.getTableName().toString(), input);
+            }
+            input['id'] = stream['id'];
+            if (!exist && input['stream_type'] == "auto")
+                yield (0, db_1.createTable)(`${this.ref}_${table}`, Object.assign(Object.assign({}, this.initColumn), column), { removePrimary });
+            if (fields.length) {
+                yield this.addStreamFieldMany(slug, namespace, fields, { stream: input });
+            }
+            return stream;
+        });
+    }
+    updateStream(slug, namespace, input = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let query = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { stream_slug: slug, stream_namespace: namespace }, attributes: ['id'], raw: true });
+            if (!query) {
+                return Promise.reject(errors_1.generalError.NOT_FOUND);
+            }
+            delete input['id'];
+            return yield (0, db_1.update)(this.ref, stream_1.StreamModel.getTableName().toString(), input, { where: { id: query['id'] } });
+        });
+    }
+    removeStreamByNamespace(namespace) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let query = yield stream_1.StreamModel.schema(this.ref, "_").findAll({
+                where: { stream_namespace: namespace }, raw: true, attributes: ['id', 'stream_prefix', 'stream_slug', 'stream_namespace', 'stream_type']
+            });
+            if (query.length) {
+                for (let stream of query) {
+                    yield this.removeStream(stream['stream_slug'], stream['stream_namespace'], { stream });
+                }
+            }
+            return { success: 1 };
+        });
+    }
+    removeStream(slug, namespace, { stream = {}, error = true } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!Object.keys(stream).length) {
+                stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({
+                    where: { stream_slug: slug, stream_namespace: namespace }, raw: true, attributes: ['id', 'stream_prefix', 'stream_slug', 'stream_namespace', 'stream_type']
+                });
+                if (!stream && error)
+                    return Promise.reject(errors_1.generalError.NOT_FOUND);
+                stream = stream || {};
+            }
+            let table = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+            let fields = yield stream_1.StreamAssociation.field.model.schema(this.ref, "_").findAll({
+                where: { stream_id: stream['id'] }, attributes: ['id'], raw: true
+            });
+            if (fields.length) {
+                let field_id = fields.map(i => i['id']);
+                yield stream_1.StreamAssociation.field.model.schema(this.ref, "_").destroy({ where: { id: field_id } });
+            }
+            yield stream_1.StreamModel.schema(this.ref, "_").destroy({ where: { id: stream['id'] } });
+            yield field_section_1.FieldSectionModel.schema(this.ref, "_").destroy({ where: { stream_id: stream['id'] } });
+            if (stream['stream_type'] == "auto")
+                yield (0, db_1.dropTable)(`${this.ref}_${table}`);
+            if (redis_1.redisReady) {
+                yield redis_1.redisClient.del(this.ref + "_stream_" + namespace + "_" + slug);
+            }
+            return true;
+        });
+    }
+    removeStreamManual(slug, { error = true } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let query = yield stream_1.StreamModel.schema(this.ref, "_").findAll({
+                where: { stream_slug: slug, stream_namespace: slug }, raw: true, attributes: ['id', 'stream_slug']
+            });
+            if (!query.length && error)
+                return Promise.reject(errors_1.generalError.NOT_FOUND);
+            let multi = redis_1.redisClient.multi();
+            let id = query.map(i => { multi.del(this.ref + "_stream_" + i['stream_slug'] + "_" + i['stream_slug']); return i['id']; });
+            if (query.length) {
+                yield stream_1.StreamModel.schema(this.ref, "_").destroy({ where: { id } });
+                yield stream_1.StreamAssociation.field.model.schema(this.ref, "_").destroy({ where: { stream_id: id } });
+                yield field_section_1.FieldSectionModel.schema(this.ref, "_").destroy({ where: { stream_id: id } });
+                if (redis_1.redisReady) {
+                    yield multi.exec();
+                }
+            }
+            return true;
+        });
+    }
+    addStreamFieldMany(slug, namespace, fields, { stream = {}, checkDuplicate = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!Object.keys(stream).length) {
+                stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({
+                    where: { stream_slug: slug, stream_namespace: namespace }, raw: true, attributes: ['id', 'stream_prefix', 'stream_slug', 'stream_namespace', 'stream_type']
+                });
+                if (!stream)
+                    return Promise.reject(errors_1.generalError.NOT_FOUND);
+            }
+            for (let field of fields) {
+                yield this.addStreamField(slug, namespace, field['field_slug'], { stream, field, checkDuplicate });
+            }
+            return { success: 1 };
+        });
+    }
+    addStreamField(slug, namespace, field_slug, { stream = {}, field = {}, opt = {}, changeTable = true, checkDuplicate = true, attributes = [] } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!Object.keys(stream).length) {
+                stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({
+                    where: { stream_slug: slug, stream_namespace: namespace }, raw: true, attributes: ['id', 'stream_prefix', 'stream_slug', 'stream_namespace', 'stream_type']
+                });
+                if (!stream)
+                    return Promise.reject(errors_1.generalError.NOT_FOUND);
+            }
+            let field_data = {};
+            if (field['field_data']) {
+                if (typeof field['field_data'] == "string") {
+                    try {
+                        field_data = JSON.parse(field['field_data']);
+                    }
+                    catch (err) { }
+                }
+                else if (typeof field['field_data'] == "object") {
+                    field_data = field['field_data'];
+                    field['field_data'] = JSON.stringify(field['field_data']);
+                }
+            }
+            let table = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+            if (stream['stream_type'] == "auto" && Object.keys(field).length) {
+                field['field_slug'] = field_slug;
+                if (checkDuplicate) {
+                    let exist = yield (0, db_1.getExistField)(`${this.ref}_${table}`, field_slug);
+                    if (exist)
+                        return Promise.reject(errors_1.generalError.SLUG_DUPLICATE);
+                }
+                if (typeof field_data['default_value'] !== 'undefined') {
+                    opt['defaultValue'] = field_data['default_value'];
+                }
+                if (changeTable) {
+                    let fields = [];
+                    switch (field['field_type']) {
+                        case (field['is_lang'] == "yes" ? field['field_type'] : ""):
+                            opt['defaultValue'] = undefined;
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.TEXT('long') }, opt));
+                            break;
+                        case "text":
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.STRING(255) }, opt));
+                            break;
+                        case "color":
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.STRING(50) }, opt));
+                            break;
+                        case "bullets":
+                        case "textarea":
+                            opt['defaultValue'] = undefined;
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.TEXT('long') }, opt));
+                            break;
+                        case "wysiwyg":
+                            opt['defaultValue'] = undefined;
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.TEXT('long') }, opt));
+                            break;
+                        case "choice":
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.STRING(255) }, opt));
+                            break;
+                        case "integer":
+                            opt['defaultValue'] = _.isNumber(opt['defaultValue']) ? opt['defaultValue'] : undefined;
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.INTEGER({ length: 11 }) }, opt));
+                            break;
+                        case "decimal":
+                            opt['defaultValue'] = _.isNumber(opt['defaultValue']) ? opt['defaultValue'] : undefined;
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.FLOAT }, opt));
+                            break;
+                        case "file":
+                        case "image":
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.CHAR(15) }, opt));
+                            break;
+                        case "encrypt":
+                            opt['defaultValue'] = undefined;
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.BLOB }, opt));
+                            break;
+                        case "datetime":
+                            fields = [field_slug];
+                            let range = field_data['range'] || {};
+                            if (range['field_target']) {
+                                fields.push(range['field_target']);
+                            }
+                            for (let field_slug of fields) {
+                                if (field_data['storage'] == "unix") {
+                                    yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.INTEGER({ length: 11 }) }, opt));
+                                }
+                                else if (field_data['storage'] == "datetime") {
+                                    let type = sequelize.DATE;
+                                    if (field_data['use_time'] == "no") {
+                                        type = sequelize.DATEONLY;
+                                    }
+                                    yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type }, opt));
+                                }
+                            }
+                            break;
+                        case "time":
+                            if (field_data['date'] && field_data['date']['field_target'])
+                                break;
+                            if (field_data['storage'] == "time") {
+                                yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.STRING(10) }, opt));
+                            }
+                            else if (field_data['storage'] == "datetime") {
+                                yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.DATE }, opt));
+                            }
+                            break;
+                        case "multiple":
+                            if (field_data['choose_stream']) {
+                                if (field_data['self_table'] != "yes") {
+                                    let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                                    if (stream) {
+                                        let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                                        yield (0, db_1.createTable)(`${this.ref}_${table}_${table_f}`, {
+                                            row_id: { type: sequelize.INTEGER, primaryKey: true },
+                                            [slug + "_id"]: { type: sequelize.INTEGER, primaryKey: true },
+                                            [table_f + "_id"]: { type: sequelize.INTEGER, primaryKey: true },
+                                            organ_id: sequelize.INTEGER
+                                        });
+                                    }
+                                }
+                                else {
+                                    yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.STRING(255) }, opt));
+                                }
+                            }
+                            break;
+                        case "relationship":
+                            opt['defaultValue'] = _.isNumber(opt['defaultValue']) ? opt['defaultValue'] : undefined;
+                            yield (0, db_1.addColumn)(`${this.ref}_${table}`, field_slug, Object.assign({ type: sequelize.INTEGER({ length: 11 }) }, opt));
+                            break;
+                    }
+                }
+            }
+            let sort_order = yield field_1.FieldModel.schema(this.ref, "_").max('sort_order', { where: { stream_id: stream['id'] } });
+            field['sort_order'] = sort_order ? Number(sort_order + 1) : 1;
+            if (!field['stream_id']) {
+                field['stream_id'] = stream['id'];
+            }
+            return yield this.upsert('fields', 'data', field, { attributes });
+        });
+    }
+    removeStreamFieldMany(slug, namespace, field_array) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({
+                where: { stream_slug: slug, stream_namespace: namespace }, raw: true, attributes: ['id', 'stream_prefix', 'stream_slug', 'stream_namespace', 'stream_type']
+            });
+            if (stream && field_array.length) {
+                for (let field_slug of field_array) {
+                    yield this.removeStreamField(slug, namespace, field_slug, { stream });
+                }
+            }
+            return { success: 1 };
+        });
+    }
+    removeStreamField(slug, namespace, field_slug, { field_id = "", stream = {} } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!Object.keys(stream).length) {
+                stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({
+                    where: { stream_slug: slug, stream_namespace: namespace }, raw: true, attributes: ['id', 'stream_prefix', 'stream_slug', 'stream_namespace', 'stream_type']
+                });
+                if (!stream)
+                    return Promise.reject(errors_1.generalError.NOT_FOUND);
+            }
+            let table = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+            let field = {};
+            if (field_id) {
+                let query = yield field_1.FieldModel.schema(this.ref, "_").findOne({ where: { stream_id: stream['id'], id: field_id }, raw: true, attributes: ['id', 'field_slug', 'field_type', 'field_data'] });
+                if (!query) {
+                    return Promise.reject(errors_1.generalError.NOT_FOUND);
+                }
+                field_slug = query['field_slug'];
+                field = query;
+            }
+            else {
+                let query = yield field_1.FieldModel.schema(this.ref, "_").findOne({ where: { stream_id: stream['id'], field_slug }, raw: true, attributes: ['id', 'field_type', 'field_data'] });
+                if (!query) {
+                    return Promise.reject(errors_1.generalError.NOT_FOUND);
+                }
+                field = query;
+            }
+            let fields = [field_slug], field_data = {};
+            if (field['field_data']) {
+                if (typeof field['field_data'] == 'object') {
+                    field_data = field['field_data'];
+                }
+                else if (typeof field['field_data'] == 'string') {
+                    try {
+                        field_data = JSON.parse(field['field_data']);
+                    }
+                    catch (err) { }
+                }
+            }
+            switch (field['field_type']) {
+                case "image":
+                case "file":
+                    let folder_slug = 'field_' + field['id'];
+                    yield this.fileUtil.removeFolder(folder_slug, { parent_folder: this.folder_parent });
+                    break;
+                case "datetime":
+                    if (field_data['range'] && field_data['range']['field_target']) {
+                        fields.push(field_data['range']['field_target']);
+                    }
+                    break;
+            }
+            yield field_1.FieldModel.schema(this.ref, "_").destroy({ where: { id: field['id'] } });
+            if (stream['stream_type'] == "auto") {
+                for (let field_slug of fields) {
+                    if (field['field_type'] == "multiple" && field_data['self_table'] != "yes") {
+                        if (field_data['choose_stream']) {
+                            let stream = yield stream_1.StreamModel.schema(this.ref, "_").findOne({ where: { id: field_data['choose_stream'] }, raw: true, attributes: ['stream_slug', 'stream_prefix'] });
+                            if (stream) {
+                                let table_f = stream['stream_prefix'] ? stream['stream_prefix'] + stream['stream_slug'] : stream['stream_slug'];
+                                yield (0, db_1.dropTable)(`${this.ref}_${table}_${table_f}`);
+                            }
+                        }
+                    }
+                    else {
+                        yield (0, db_1.removeColumn)(`${this.ref}_${table}`, field_slug);
+                    }
+                }
+            }
+            return { success: 1 };
+        });
+    }
+    inputFieldData(field_type, field_data) {
+        switch (field_type) {
+            case "text":
+                if (field_data['transform.field_target']) {
+                    let result = dottie.transform(field_data);
+                    field_data['transform'] = result['transform'];
+                }
+                field_data = _.pick(field_data, ['max_length', 'default_value', 'regex', 'transform']);
+                break;
+            case "email":
+                field_data = _.pick(field_data, ['default_value']);
+                break;
+            case "integer":
+                field_data = _.pick(field_data, ['min_value', 'max_value', 'default_value']);
+                break;
+            case "choice":
+                field_data = _.pick(field_data, ['choice_data', 'default_value', 'choice_type', 'min_choices', 'max_choices', 'use_single']);
+                break;
+            case "color":
+            case "textarea":
+                field_data = _.pick(field_data, ['default_value']);
+                break;
+            case "wysiwyg":
+                field_data = _.pick(field_data, ['editor_type']);
+                break;
+            case "decimal":
+                field_data = _.pick(field_data, ['decimal_places', 'min_value', 'max_value', 'default_value']);
+                break;
+            case "image":
+                field_data = _.pick(field_data, ['resize_width', 'resize_hight', 'allowed_types']);
+                break;
+            case "file":
+                field_data = _.pick(field_data, ['allowed_types']);
+                break;
+            case "datetime":
+                if (field_data['range.field_target']) {
+                    let result = dottie.transform(field_data);
+                    field_data['range'] = result['range'];
+                }
+                field_data = _.pick(field_data, ['storage', 'use_time', 'start_date', 'end_date', 'range']);
+                break;
+            case "time":
+                if (field_data['date.field_target']) {
+                    let result = dottie.transform(field_data);
+                    field_data['date'] = result['date'];
+                }
+                field_data = _.pick(field_data, ['storage', 'date', 'default_value']);
+                break;
+            case "encrypt":
+                field_data = _.pick(field_data, ['hide_typing']);
+                break;
+            case "relationship":
+                field_data = _.pick(field_data, ['choose_stream', 'skip_data']);
+                break;
+            case "multiple":
+                field_data = _.pick(field_data, ['choose_stream', 'skip_data', 'self_table', 'regex']);
+                break;
+            default:
+                field_data = null;
+                break;
+        }
+        return field_data;
+    }
+    getValidator(streams, { schema = {}, input = {}, req = {}, isNew = false, lang = [], required = true, stripUnknown = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let field_lang = [];
+            let file = (req.file ? [req.file] : [].concat(req.files || [])).reduce((total, item) => Object.assign(total, { [item['fieldname']]: item }), {});
+            streams.forEach(({ field_type, field_slug, is_required, is_lang, field_data, data }) => {
+                let field;
+                field_data = field_data || {};
+                is_required = (is_required == "yes" && (isNew || (!input[field_slug] && typeof input[field_slug] != "undefined")));
+                if (isNew && (typeof input[field_slug] == "undefined" && field_data['default_value'])) {
+                    input[field_slug] = field_data['default_value'];
+                }
+                switch (field_type) {
+                    case "text":
+                    case "textarea":
+                    case "wysiwyg":
+                    case "bullets":
+                    case "email":
+                        field = Joi.string();
+                        if (field_type == "email")
+                            field = field.email();
+                        if (typeof field_data['min_length'] != "undefined" && !Joi.number().validate(field_data['min_length']).error)
+                            field = field.min(Number(field_data['min_length']));
+                        if (typeof field_data['max_length'] != "undefined" && !Joi.number().validate(field_data['max_length']).error)
+                            field = field.max(Number(field_data['max_length']));
+                        if (field_data['regex'])
+                            field = field.regex(new RegExp(field_data['regex']));
+                        if (!is_required)
+                            field = field.allow(null, '');
+                        break;
+                    case "integer":
+                    case "decimal":
+                        field = Joi.number();
+                        if (field_type == "decimal") {
+                            let places = (typeof field_data['decimal_places'] != "undefined" && !Joi.number().validate(field_data['decimal_places']).error) ? Number(field_data['decimal_places']) : 2;
+                            field = field.precision(places);
+                        }
+                        if (typeof field_data['min_value'] != "undefined" && !Joi.number().validate(field_data['min_value']).error)
+                            field = field.min(Number(field_data['min_value']));
+                        if (typeof field_data['max_value'] != "undefined" && !Joi.number().validate(field_data['max_value']).error)
+                            field = field.max(Number(field_data['max_value']));
+                        if (!is_required)
+                            field = field.allow(null, '');
+                        break;
+                    case "choice":
+                        if (typeof input[field_slug] != "undefined") {
+                            if (typeof input[field_slug] == "number") {
+                                input[field_slug] = String(input[field_slug]);
+                            }
+                            else {
+                                input[field_slug] = String(input[field_slug] || '');
+                            }
+                        }
+                        field = Joi.string();
+                        data = (data || []).map(i => i['key']);
+                        if (field_data['choice_type'] == "checkboxes") {
+                            let regex = new RegExp(`^(${data.join('|')})$`);
+                            let invalid = String(input[field_slug] || "").split(",").find((value) => !regex.test(value || ""));
+                            if (typeof invalid == "undefined")
+                                break;
+                        }
+                        if (!is_required && field_data['choice_type'] != "dropdown")
+                            field = field.allow(null, '');
+                        field = field.valid(...data);
+                        break;
+                    case "datetime":
+                        field = helper_1.Joi_date.date().format('YYYY-MM-DD HH:mm:ss').raw();
+                        if (field_data['storage'] == "unix") {
+                            input[field_slug] = String(input[field_slug] || "");
+                            field = Joi.string().length(10).regex(/^[0-9]+$/);
+                        }
+                        else if (field_data['storage'] == "datetime") {
+                            if (field_data['use_time'] == "no") {
+                                field = helper_1.Joi_date.date().format('YYYY-MM-DD').raw();
+                            }
+                        }
+                        if (!is_required)
+                            field = field.allow(null, '');
+                        break;
+                    case "time":
+                        if (field_data['date'] && field_data['date']['field_target'])
+                            break;
+                        field = helper_1.Joi_date.date().format('HH:mm:ss').raw();
+                        if (!is_required)
+                            field = field.allow(null, '');
+                        break;
+                    case "file":
+                    case "image":
+                        if (input[field_slug] && String(input[field_slug]).length != 15) {
+                            delete input[field_slug];
+                        }
+                        field = Joi.string();
+                        if (!is_required)
+                            field = field.allow(null, '');
+                        if (file[field_slug]) {
+                            is_required = false;
+                            let allow_type = false;
+                            if (field_type == "image" && !field_data['allowed_types']) {
+                                allow_type = new RegExp(/^(image.*)$/).test(file[field_slug]['mimetype']);
+                                if (!allow_type) {
+                                    input[field_slug] = mime.extension(file[field_slug]['mimetype']);
+                                    field = Joi.string().valid('image/*');
+                                }
+                            }
+                            if (!allow_type && field_data['allowed_types']) {
+                                let extension = String(mime.extension(file[field_slug]['mimetype']));
+                                if (!new RegExp(`^(${field_data['allowed_types']})$`).test(extension)) {
+                                    input[field_slug] = extension;
+                                    field = Joi.string().valid(...(field_data['allowed_types'].split('|') || []));
+                                }
+                            }
+                        }
+                        break;
+                    case "relationship":
+                    case "multiple":
+                        let regex = /^\d+$/;
+                        field = Joi.string();
+                        if (!is_required)
+                            field = field.allow(null, '');
+                        if (field_type == "multiple") {
+                            regex = field_data['regex'] || /^(\d+)(,\s*\d+)*$/;
+                        }
+                        field = field.regex(new RegExp(regex));
+                        if (field_type == "relationship") {
+                            field = Joi.alternatives(Joi.number(), field);
+                        }
+                        break;
+                }
+                field = field || Joi.any();
+                if (is_required)
+                    field = field.required();
+                if (is_lang == "yes") {
+                    if (!lang.length) {
+                        field_lang.push({ field_slug, field });
+                        return;
+                    }
+                    field = Joi.object().keys(lang.reduce((total, i) => Object.assign(total, { [i['lang_code']]: field }), {}));
+                }
+                schema[field_slug] = field;
+            });
+            if (field_lang.length) {
+                lang = yield this.languageUtil.getLangsLive();
+                for (let item of field_lang) {
+                    let field = item['field'];
+                    if (lang.length)
+                        field = Joi.object().keys(lang.reduce((total, i) => Object.assign(total, { [i['lang_code']]: field }), {}));
+                    schema[item['field_slug']] = field;
+                }
+            }
+            let validator = stripUnknown ? Joi.object().keys(schema).options({ stripUnknown: true }) : Joi.object().keys(schema).unknown();
+            if (required)
+                validator = validator.required();
+            return validator;
+        });
+    }
+    getValidatorSchema(slug, namespace, { req = {}, isNew = false, required = true, lang = [], stripUnknown = false, builder = true } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let streams = yield this.getBuilder(slug, namespace, { index: "fields", builder });
+            return yield this.getValidator(streams, { req, isNew, required, lang, stripUnknown });
+        });
+    }
+    validate(slug, namespace, input, { req = {}, isNew = false, default_value = {}, lang = [], stripUnknown = false, inputLang = false, inputLangSeparate = true, prefixMessage = "", builder = true, field_exclude = [] } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let streams = yield this.getBuilder(slug, namespace, { index: "fields", builder, field_exclude });
+            return this.validateByField(streams, input, { req, isNew, default_value, lang, stripUnknown, inputLang, inputLangSeparate, prefixMessage });
+        });
+    }
+    validateByField(streams, input, { req = {}, isNew = false, default_value = {}, lang = [], stripUnknown = false, inputLang = false, inputLangSeparate = true, prefixMessage = "" } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (streams && streams.length) {
+                let validator = yield this.getValidator(streams, { input, req, isNew, lang, stripUnknown });
+                input = yield (0, validator_1.validate)(validator, Object.assign(Object.assign({}, input), default_value), { prefixMessage });
+                if (inputLang) {
+                    input = yield this.getInputByLang(input, { separate: inputLangSeparate, lang });
+                }
+            }
+            else if (stripUnknown) {
+                input = {};
+            }
+            return input;
+        });
+    }
+}
+exports.StreamUtil = StreamUtil;