@digione/node-custom-api 0.1.7 → 0.1.8-beta2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digione/node-custom-api",
-  "version": "0.1.7",
+  "version": "0.1.8-beta2",
   "description": "Typescript node digione-api",
   "author": "Monchai Jirayupong <monchai.j@seven.co.th>",
   "license": "MIT",

package/utils/helper.d.ts

@@ -18,8 +18,9 @@ export declare const getTimestampMysql: (date?: any) => number;
 export declare const getDateTime: (time?: any, { utc }?: {
     utc?: boolean;
 }) => moment.Moment;
-export declare const getValueFunctionFile: (key: any) => (value: any, { result, fileUtil }?: {
+export declare const getValueFunctionFile: (key: any) => (value: any, { result, json, fileUtil }?: {
     result?: {};
+    json?: {};
     fileUtil?: any;
 }) => Promise<void>;
 export declare const getValueFunctionLang: (key: any) => (value?: {}, { result, transform, spread, spread_all, raw, lang_code }?: {

package/utils/helper.js

@@ -79,8 +79,16 @@ const getDateTime = (time = undefined, { utc = true } = {}) => {
 };
 exports.getDateTime = getDateTime;
 const getValueFunctionFile = (key) => {
-    return (value, { result = {}, fileUtil = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-        if (value[key]) {
+    return (value, { result = {}, json = {}, fileUtil = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        if (json[key]) {
+            try {
+                result[key] = JSON.parse(json[key]);
+            }
+            catch (err) {
+                result[key] = null;
+            }
+        }
+        else if (value[key]) {
             result[key] = yield fileUtil.findOneFileById(value[key]);
         }
     });

package/utils/stream.d.ts

@@ -5,16 +5,20 @@ import { Request } from 'express';
 import * as Joi from 'joi';
 export declare const getValueFunctionRelationship: (key: any, { field_data }?: {
     field_data?: {};
-}) => (value: any, { result, ref, lang_code }?: {
+}) => (value: any, { result, json, ref, raw, lang_code }?: {
     result?: {};
+    json?: {};
     ref?: string;
+    raw?: boolean;
     lang_code?: string;
 }) => Promise<void>;
 export declare const getValueFunctionMultiple: (key: any, { field_data }?: {
     field_data?: {};
-}) => (value: any, { result, ref, lang_code }?: {
+}) => (value: any, { result, json, ref, raw, lang_code }?: {
     result?: {};
+    json?: {};
     ref?: string;
+    raw?: boolean;
     lang_code?: string;
 }) => Promise<void>;
 interface Field {
@@ -71,14 +75,16 @@ export declare class StreamUtil {
         include?: any;
         include_only?: boolean;
     }): any;
-    buildStream(slug: string, namespace: string, { query, builder, fetch, attribute, attributes, field_exclude, include }?: {
+    buildStream(slug: string, namespace: string, { query, builder, fetch, label, attribute, attributes, field_exclude, include, include_all }?: {
         query?: boolean;
         builder?: boolean;
         fetch?: boolean;
+        label?: boolean;
         attribute?: boolean;
         attributes?: any;
         field_exclude?: any[];
         include?: {};
+        include_all?: boolean;
     }): Promise<{
         stream: any;
         fields: any;
@@ -99,6 +105,18 @@ export declare class StreamUtil {
         raw?: boolean;
         lang_code?: any;
     }): Promise<{}>;
+    getValueByJson(slug: string, namespace: string, value: any, json: any, { query, lang_code }?: {
+        query?: boolean;
+        lang_code?: any;
+    }): Promise<{}>;
+    getStoreJson(slug: string, namespace: string, value: any, { query, lang_code, exclude_type }?: {
+        query?: boolean;
+        lang_code?: any;
+        exclude_type?: {};
+    }): Promise<{
+        result: {};
+        labels: any[];
+    }>;
     genField(streams: Array<any>, { index, option, slug, id_stream, prefix, multiple_table, multiple_spread, addition, convert_option, field_option, default_value, default_lang, lang_code, no_lang, lang, country, section }?: {
         index?: string;
         option?: {};

package/utils/stream.js

@@ -24,10 +24,22 @@ 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']) {
+    return (value, { result = {}, json = {}, ref = '', raw = false, lang_code = '' } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        if (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 (json[key]) {
+                try {
+                    result[key] = JSON.parse(json[key]);
+                }
+                catch (err) {
+                    result[key] = null;
+                }
+            }
+            else if (value[key]) {
+                result[key] = yield (0, db_1.findOne)(ref + '_' + field_data['table'], { where: { id: value[key] }, attributes: ['*'] });
+            }
+            if (raw)
+                return;
             if (result[key]) {
                 (0, helper_2.getValueFunctionLang)(title_column)(result[key], { result: result[key], lang_code });
             }
@@ -36,10 +48,22 @@ const getValueFunctionRelationship = (key, { field_data = {} } = {}) => {
 };
 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']) {
+    return (value, { result = {}, json = {}, ref = '', raw = false, lang_code = '' } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        if (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 (json[key]) {
+                try {
+                    result[key] = JSON.parse(json[key]);
+                }
+                catch (err) {
+                    result[key] = [];
+                }
+            }
+            else if (field_data['association']) {
+                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 (raw)
+                return;
             if (result[key] && result[key].length) {
                 result[key] = result[key].map(i => (0, helper_2.getValueByLang)(i, { result: i, field: [title_column], lang_code }));
             }
@@ -211,7 +235,7 @@ class StreamUtil {
         }
         return data;
     }
-    buildStream(slug, namespace, { query = true, builder = true, fetch = false, attribute = false, attributes = null, field_exclude = [], include = {} } = {}) {
+    buildStream(slug, namespace, { query = true, builder = true, fetch = false, label = false, attribute = false, attributes = null, field_exclude = [], include = {}, include_all = false } = {}) {
         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']) {
@@ -222,7 +246,7 @@ class StreamUtil {
                 build['stream'] = _.omit(data, ['fields']);
             }
             if ((fetch || attribute) && build['fields'].length) {
-                let fetchFn = [];
+                let fetchFn = [], fetchLabel = [];
                 attributes = attributes || {};
                 for (let field of build['fields']) {
                     let field_data = field['field_data'] || {};
@@ -232,24 +256,30 @@ class StreamUtil {
                     }
                     if (fetch) {
                         if (field['is_lang'] == "yes") {
+                            label && fetchLabel.push(field);
                             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']));
+                                    if (include[field['field_slug']] || include_all) {
+                                        label && fetchLabel.push(field);
+                                        fetchFn.push((0, helper_2.getValueFunctionFile)(field['field_slug']));
+                                    }
                                     break;
                                 case "relationship":
                                 case "multiple":
-                                    if (include[field['field_slug']] && field_data['choose_stream']) {
+                                    if ((include[field['field_slug']] || include_all) && 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") {
+                                                label && fetchLabel.push(field);
                                                 fetchFn.push((0, exports.getValueFunctionRelationship)(field['field_slug'], { field_data }));
                                             }
                                             else if (field['field_type'] == "multiple") {
+                                                label && fetchLabel.push(field);
                                                 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 }));
                                             }
@@ -264,6 +294,7 @@ class StreamUtil {
                     }
                 }
                 build['fetchFn'] = fetchFn;
+                build['fetchLabel'] = fetchLabel;
             }
             if (attributes)
                 build['attributes'] = attributes;
@@ -289,6 +320,33 @@ class StreamUtil {
             return result;
         });
     }
+    getValueByJson(slug, namespace, value, json, { query = 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, json, ref: this.ref, lang_code, fileUtil: this.fileUtil });
+            }
+            return result;
+        });
+    }
+    getStoreJson(slug, namespace, value, { query = false, lang_code = undefined, exclude_type = {} } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let result = {}, labels = [];
+            let fetchLabel = yield this.getBuilder(slug, namespace, { query, index: "fetchLabel" });
+            lang_code = lang_code || this.option.lang_code;
+            for (let f of fetchLabel || []) {
+                let field_slug = f['field_slug'];
+                let field_type = f['field_type'];
+                if (field_slug && !exclude_type[field_type] && typeof value[field_slug] != "undefined") {
+                    labels.push(field_slug);
+                    result[field_slug] = JSON.stringify(value[field_slug]);
+                }
+            }
+            return { result, labels };
+        });
+    }
     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 = [];
@@ -1742,7 +1800,7 @@ class StreamUtil {
     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 }), {});
+            let file = req ? ((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 || {};

package/utils/user.d.ts

@@ -36,8 +36,9 @@ export declare const getUserInOrgan: (ref: string, { where, organ_id, attributes
     attributes?: string[];
     parent?: boolean;
 }) => Promise<sequelize.Model<any, any>>;
-export declare const convertAddress: (data: any, { lang_code }?: {
+export declare const convertAddress: (data: any, { lang_code, transform }?: {
     lang_code?: string;
+    transform?: boolean;
 }) => Promise<any>;
 export declare const getAddressIndex: (data: any, { condition, lang_code }?: {
     condition?: {};

package/utils/user.js

@@ -177,36 +177,54 @@ const getUserInOrgan = (ref, { where = {}, organ_id = "", attributes = ['id', 'o
     });
 });
 exports.getUserInOrgan = getUserInOrgan;
-const convertAddress = (data, { lang_code = "en" } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-    let where = { lang_code: [lang_code, "en"], status: '1' };
+const convertAddress = (data, { lang_code = "en", transform = false } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let where = { lang_code: [lang_code, "en"], status: '1' }, limit = 1, attributes = [];
     let order = [sequelize.literal(`FIELD(lang_code,${'\'' + where['lang_code'].join('\',\'') + '\''})`)];
+    if (transform) {
+        where = { status: '1' };
+        attributes = ['lang_code'];
+        limit = undefined;
+        order = undefined;
+    }
     if (data['country_id']) {
-        let country = yield country_1.CountryModel.schema("core", "_").findOne({
-            raw: true, where: Object.assign(Object.assign({}, where), { id: data['country_id'] }), attributes: ['country_name'], order
+        let country = yield country_1.CountryModel.schema("core", "_").findAll({
+            raw: true, where: Object.assign(Object.assign({}, where), { id: data['country_id'] }), attributes: ['country_name', ...attributes], order, limit
         });
-        if (country)
-            data['country'] = country['country_name'];
+        if (country.length) {
+            data['country'] = country[0]['country_name'];
+            if (transform)
+                data['country'] = JSON.stringify(country.reduce((total, item) => Object.assign(total, { [item['lang_code']]: item['country_name'] }), {}));
+        }
     }
     if (data['state_id']) {
-        let state = yield state_1.StateModel.schema("core", "_").findOne({
-            raw: true, where: Object.assign(Object.assign({}, where), { id: data['state_id'] }), attributes: ['state_name'], order
+        let state = yield state_1.StateModel.schema("core", "_").findAll({
+            raw: true, where: Object.assign(Object.assign({}, where), { id: data['state_id'] }), attributes: ['state_name', ...attributes], order, limit
         });
-        if (state)
-            data['state'] = state['state_name'];
+        if (state.length) {
+            data['state'] = state[0]['state_name'];
+            if (transform)
+                data['state'] = JSON.stringify(state.reduce((total, item) => Object.assign(total, { [item['lang_code']]: item['state_name'] }), {}));
+        }
     }
     if (data['city_id']) {
-        let city = yield city_1.CityModel.schema("core", "_").findOne({
-            raw: true, where: Object.assign(Object.assign({}, where), { id: data['city_id'] }), attributes: ['city_name'], order
+        let city = yield city_1.CityModel.schema("core", "_").findAll({
+            raw: true, where: Object.assign(Object.assign({}, where), { id: data['city_id'] }), attributes: ['city_name', ...attributes], order, limit
         });
-        if (city)
-            data['city'] = city['city_name'];
+        if (city.length) {
+            data['city'] = city[0]['city_name'];
+            if (transform)
+                data['city'] = JSON.stringify(city.reduce((total, item) => Object.assign(total, { [item['lang_code']]: item['city_name'] }), {}));
+        }
     }
     if (data['district_id']) {
-        let district = yield district_1.DistrictModel.schema("core", "_").findOne({
-            raw: true, where: Object.assign(Object.assign({}, where), { id: data['district_id'] }), attributes: ['district_name'], order
+        let district = yield district_1.DistrictModel.schema("core", "_").findAll({
+            raw: true, where: Object.assign(Object.assign({}, where), { id: data['district_id'] }), attributes: ['district_name', ...attributes], order, limit
         });
-        if (district)
-            data['district'] = district['district_name'];
+        if (district.length) {
+            data['district'] = district[0]['district_name'];
+            if (transform)
+                data['district'] = JSON.stringify(district.reduce((total, item) => Object.assign(total, { [item['lang_code']]: item['district_name'] }), {}));
+        }
     }
     return data;
 });