@digione/node-custom-api 0.0.1

package/utils/helper.d.ts

@@ -0,0 +1,113 @@
+import * as moment from 'moment';
+export declare const getDateRangeFormat: (dates?: any, { format: { day, month, year } }?: {
+    format?: {
+        day?: string;
+        month?: string;
+        year?: string;
+    };
+}) => string;
+export declare const getDateFromString: (value: any) => Date;
+export declare const getDaysBetweenDates: (startDate: any, endDate: any, { utc }?: {
+    utc?: boolean;
+}) => any[];
+export declare const Joi_date: any;
+export declare const getENV: (str: string, def?: any) => any;
+export declare const getSlug: (length?: number) => string;
+export declare const getDateMysql: (date?: any) => any;
+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 }?: {
+    result?: {};
+    fileUtil?: any;
+}) => Promise<void>;
+export declare const getValueFunctionLang: (key: any) => (value?: {}, { result, transform, spread, spread_all, raw, lang_code }?: {
+    result?: {};
+    transform?: boolean;
+    spread?: boolean;
+    spread_all?: boolean;
+    raw?: boolean;
+    lang_code?: string;
+}) => void;
+export declare const getValueByLang: (value: any, { result, field, lang_code, transform, raw }?: {
+    result?: {};
+    field?: any[];
+    lang_code?: string;
+    transform?: boolean;
+    raw?: boolean;
+}) => any;
+export declare const sleep: any;
+export declare const getUUID: () => string;
+export declare const getUUID32: () => string;
+export declare const getTokenDataFromTokenBySecret: (token: string, secret: string) => Promise<any>;
+export declare const signToken: (secret: string, opt?: any) => string;
+export declare const removeHyphen: (str: string, replace?: string, { encode, replace_word }?: {
+    encode?: boolean;
+    replace_word?: string;
+}) => string;
+export declare const getMobileNumber: (str: string, { prefix }?: {
+    prefix?: string;
+}) => string;
+export declare const removeSpace: (str: string, replace?: string) => string;
+export declare const removeAt: (str: string, replace?: string) => string;
+export declare const isNumber: (val: any, { negative }?: {
+    negative?: boolean;
+}) => boolean;
+export declare const isBase64: (val: any) => boolean;
+export declare const multiExecArray: (multi: any, { json_parse }?: {
+    json_parse?: boolean;
+}) => Promise<any[]>;
+export declare const randomRef: ({ length_digital, length_alphabet }?: {
+    length_digital?: number;
+    length_alphabet?: number;
+}) => string;
+export declare const treeToArray: (items: Array<any>, array?: Array<any>, level?: number) => Promise<any[]>;
+export declare const buildTree: (nodes: Array<any>, { index, field_children, json_convert, key_index, key_parent, root, to_array }?: {
+    index?: any;
+    field_children?: string;
+    json_convert?: boolean;
+    key_index?: string;
+    key_parent?: string;
+    root?: any;
+    to_array?: boolean;
+}) => Promise<any[]>;
+export declare const expandTree: (items: Array<any>, { array, parent, level, prefix, field_index, field_children, key_value }?: {
+    array?: any[];
+    parent?: any;
+    level?: number;
+    prefix?: string;
+    field_index?: string;
+    field_children?: string;
+    key_value?: string;
+}) => any[];
+export declare const convertToBigEndian: (text: string) => string;
+export declare const slugify: (string?: any, { lowercase }?: {
+    lowercase?: boolean;
+}) => any;
+export declare const slugifyField: (string?: any) => any;
+export declare const stripHtml: (string: string) => string;
+export declare const replaceColon: (string: string, { decode }?: {
+    decode?: boolean;
+}) => string;
+export declare const getParent: (nodes: Array<any>, { id, key_index }?: {
+    id?: string;
+    key_index?: string;
+}) => any;
+export declare const getDomain: (domain: string) => Promise<string>;
+export declare const getInstanceNumber: () => string;
+export declare const xorEncode: (str: string, key?: string) => string;
+export declare const xorDecode: (str: string, key?: string) => string;
+export declare const xorMerge: (str: string, key: string) => string;
+export declare const convertCurrency: (data: any, currency?: any, { fields, fields_tax, fn_value, fn_field, fn_tax, setting, vat_value, tax_include, tax_dif, obj_format }?: {
+    fields?: any[];
+    fields_tax?: any[];
+    fn_value?: {};
+    fn_field?: {};
+    fn_tax?: {};
+    setting?: boolean;
+    vat_value?: number;
+    tax_include?: boolean;
+    tax_dif?: boolean;
+    obj_format?: {};
+}) => {};

package/utils/helper.js

@@ -0,0 +1,508 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertCurrency = exports.xorMerge = exports.xorDecode = exports.xorEncode = exports.getInstanceNumber = exports.getDomain = exports.getParent = exports.replaceColon = exports.stripHtml = exports.slugifyField = exports.slugify = exports.convertToBigEndian = exports.expandTree = exports.buildTree = exports.treeToArray = exports.randomRef = exports.multiExecArray = exports.isBase64 = exports.isNumber = exports.removeAt = exports.removeSpace = exports.getMobileNumber = exports.removeHyphen = exports.signToken = exports.getTokenDataFromTokenBySecret = exports.getUUID32 = exports.getUUID = exports.sleep = exports.getValueByLang = exports.getValueFunctionLang = exports.getValueFunctionFile = exports.getDateTime = exports.getTimestampMysql = exports.getDateMysql = exports.getSlug = exports.getENV = exports.Joi_date = exports.getDaysBetweenDates = exports.getDateFromString = exports.getDateRangeFormat = void 0;
+const tslib_1 = require("tslib");
+const crypto = require("crypto");
+const dotenv = require("dotenv");
+const moment = require("moment");
+const uuid_1 = require("uuid");
+const short_unique_id_1 = require("short-unique-id");
+const jwt = require("jsonwebtoken");
+const Joi = require("joi");
+const date_1 = require("@joi/date");
+const numeral = require("numeral");
+const _ = require("lodash");
+const sha1 = require('js-sha1');
+dotenv.config();
+const getDateRangeFormat = (dates = [], { format: { day = "D", month = "MMM", year = "Y" } = {} } = {}) => {
+    dates = dates.map(i => (0, exports.getDateTime)(i));
+    const min = moment.min(dates);
+    const max = moment.max(dates);
+    let start = "", end = max.format(day) + " " + max.format(month) + " " + max.format(year);
+    if (!min.isSame(max)) {
+        start = min.format(day);
+        if (!min.isSame(max, 'month')) {
+            start = start + " " + min.format(month);
+        }
+        if (!min.isSame(max, 'year')) {
+            start = start + " " + min.format(year);
+        }
+        start = start + " - ";
+    }
+    let result = start + end;
+    return result;
+};
+exports.getDateRangeFormat = getDateRangeFormat;
+const getDateFromString = (value) => {
+    if (value instanceof Date) {
+        return value;
+    }
+    let str = value.split(' ');
+    return new Date(`${str[0]}T${str[1] || '00:00:00'}.000Z`);
+};
+exports.getDateFromString = getDateFromString;
+const getDaysBetweenDates = (startDate, endDate, { utc = true } = {}) => {
+    let dates = [];
+    let currDate = (0, exports.getDateTime)(startDate, { utc }).startOf('day');
+    let lastDate = (0, exports.getDateTime)(endDate, { utc }).endOf('day');
+    dates.push(currDate.toDate());
+    while (currDate.add(1, 'days').diff(lastDate) < 0) {
+        dates.push(currDate.clone().toDate());
+    }
+    return dates;
+};
+exports.getDaysBetweenDates = getDaysBetweenDates;
+exports.Joi_date = Joi.extend(date_1.default);
+const getENV = (str, def) => {
+    return process.env[str] || def;
+};
+exports.getENV = getENV;
+const getSlug = (length = 8) => {
+    return new short_unique_id_1.default().randomUUID(length);
+};
+exports.getSlug = getSlug;
+const getDateMysql = (date = undefined) => {
+    try {
+        return (0, exports.getDateTime)(date).format("YYYY-MM-DD HH:mm:ss");
+    }
+    catch (err) {
+        return date;
+    }
+};
+exports.getDateMysql = getDateMysql;
+const getTimestampMysql = (date = undefined) => {
+    return ((0, exports.getDateTime)(date).unix());
+};
+exports.getTimestampMysql = getTimestampMysql;
+const getDateTime = (time = undefined, { utc = true } = {}) => {
+    return utc ? moment(time).utc() : moment(time);
+};
+exports.getDateTime = getDateTime;
+const getValueFunctionFile = (key) => {
+    return (value, { result = {}, fileUtil = undefined } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        if (value[key]) {
+            result[key] = yield fileUtil.findOneFileById(value[key]);
+        }
+    });
+};
+exports.getValueFunctionFile = getValueFunctionFile;
+const getValueFunctionLang = (key) => {
+    return (value = {}, { result = {}, transform = true, spread = false, spread_all = false, raw = false, lang_code = "" } = {}) => {
+        if (raw || typeof value[key] == "undefined")
+            return;
+        let obj = {}, bol = false;
+        try {
+            obj = JSON.parse(value[key]);
+            if (spread) {
+                result[key] = undefined;
+                result[key + "_" + lang_code] = (obj[lang_code] || obj['en']);
+                if (spread_all) {
+                    Object.keys(obj).forEach((k) => Object.assign(result, { [key + "_" + k]: obj[k] }), {});
+                }
+                return;
+            }
+            bol = true;
+        }
+        catch (err) { }
+        obj = obj || {};
+        if (!transform) {
+            result[key] = obj;
+            return;
+        }
+        result[key] = bol ? (obj[lang_code] || obj['en']) : value[key];
+    };
+};
+exports.getValueFunctionLang = getValueFunctionLang;
+const getValueByLang = (value, { result = {}, field = [], lang_code = "en", transform = true, raw = false } = {}) => {
+    for (let key of field) {
+        (0, exports.getValueFunctionLang)(key)(value, { result, lang_code, transform, raw });
+    }
+    return result;
+};
+exports.getValueByLang = getValueByLang;
+exports.sleep = require('util').promisify(setTimeout);
+const getUUID = () => (0, uuid_1.v4)();
+exports.getUUID = getUUID;
+const getUUID32 = () => (0, uuid_1.v4)().replace(/-/g, '');
+exports.getUUID32 = getUUID32;
+const getTokenDataFromTokenBySecret = (token, secret) => tslib_1.__awaiter(void 0, void 0, void 0, function* () { return jwt.verify(token, secret); });
+exports.getTokenDataFromTokenBySecret = getTokenDataFromTokenBySecret;
+const signToken = (secret, opt = {}) => {
+    return jwt.sign(Object.assign({}, opt), secret);
+};
+exports.signToken = signToken;
+const removeHyphen = (str, replace = "", { encode = false, replace_word = "a" } = {}) => {
+    if (encode) {
+        str = str ? str.replace(/[`~!@#$%^&*()|+=?;:'",.<>\{\}\[\]\\\/]/gi, replace_word) : "";
+        if (str)
+            str = encodeURIComponent(str).replace(/%/g, '');
+    }
+    else {
+        str = str ? str.replace(/\W/g, replace_word) : "";
+    }
+    return str ? str.replace(/-/g, replace).toLowerCase() : "";
+};
+exports.removeHyphen = removeHyphen;
+const getMobileNumber = (str, { prefix = "+66" } = {}) => {
+    if (str) {
+        str = str.replace(/_/g, "").replace(/-/g, "").replace(/ /g, "");
+        if (str.indexOf("+") == -1 && str.length == 10) {
+            str = str.substr(1);
+            str = prefix + str;
+        }
+    }
+    return str;
+};
+exports.getMobileNumber = getMobileNumber;
+const removeSpace = (str, replace = "") => {
+    return str ? str.replace(/ /g, replace) : "";
+};
+exports.removeSpace = removeSpace;
+const removeAt = (str, replace = "_") => {
+    return str ? str.replace(/@/g, replace) : "";
+};
+exports.removeAt = removeAt;
+const isNumber = (val, { negative = false } = {}) => {
+    let regx = new RegExp(/^\d+$/);
+    if (negative) {
+        regx = new RegExp(/^-?\d+$/);
+    }
+    return regx.test(val);
+};
+exports.isNumber = isNumber;
+const isBase64 = (val) => {
+    let reg = new RegExp("^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$");
+    return reg.test(val);
+};
+exports.isBase64 = isBase64;
+const multiExecArray = (multi, { json_parse = false } = {}) => {
+    return new Promise((resolve, reject) => {
+        multi.exec((err, data) => {
+            if (json_parse) {
+                data = data.map(item => {
+                    if (item instanceof Array)
+                        item = item[1];
+                    return JSON.parse(item);
+                });
+            }
+            resolve(data);
+        });
+    });
+};
+exports.multiExecArray = multiExecArray;
+const randomRef = ({ length_digital = 3, length_alphabet = 1 } = {}) => {
+    let ref = "";
+    let array = (Array(length_alphabet).fill('a')).concat(Array(length_digital).fill('d'));
+    let possible_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    let possible_digital = "0123456789";
+    array = _.shuffle(array);
+    for (let i = 0; i < array.length; i++) {
+        if (array[i] == 'a') {
+            ref += possible_alphabet.charAt(Math.floor(Math.random() * possible_alphabet.length));
+        }
+        else if (array[i] == 'd') {
+            ref += possible_digital.charAt(Math.floor(Math.random() * possible_digital.length));
+        }
+    }
+    return ref;
+};
+exports.randomRef = randomRef;
+const treeToArray = (items, array = [], level = 1) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    items.forEach(item => {
+        if (item['children']) {
+            array.push(Object.assign(Object.assign({}, item), { children: undefined }));
+            return (0, exports.treeToArray)(item['children'], array, level + 1);
+        }
+        else {
+            array.push(Object.assign({}, item));
+        }
+    });
+    return array;
+});
+exports.treeToArray = treeToArray;
+const buildTree = (nodes, { index = undefined, field_children = "children", json_convert = false, key_index = "id", key_parent = "parent", root = undefined, to_array = false } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (!nodes) {
+        return null;
+    }
+    if (json_convert) {
+        nodes = JSON.parse(JSON.stringify(nodes));
+    }
+    if (index)
+        root = [index];
+    let roots = [], children = {}, use_root = false;
+    let obj_root = root ? [].concat(root).reduce((total, item) => Object.assign(total, { [item]: {} }), {}) : {};
+    if (root instanceof Array) {
+        use_root = true;
+    }
+    for (let i = 0, len = nodes.length; i < len; ++i) {
+        let item = nodes[i], k = item[key_index], p = item[key_parent], c = use_root ? k : p, target = (!root && !p || obj_root[c]) ? roots : (children[p] || (children[p] = []));
+        if (use_root && obj_root[c]) {
+            children[p] = (children[p] || []).concat([item]);
+            if (obj_root[p]) {
+                obj_root[p][k] = true;
+                continue;
+            }
+        }
+        target.push(item);
+    }
+    let findChildren = function (parent) {
+        if (children[parent[key_index]]) {
+            let results;
+            for (let i = 0, len = children[parent[key_index]].length; i < len; ++i) {
+                let item = children[parent[key_index]][i];
+                let obj_children = obj_root[parent[key_index]] || {};
+                if (!use_root || !Object.keys(obj_children).length || obj_children[item[key_index]]) {
+                    obj_root[item[key_index]] = obj_root[item[key_index]] || {};
+                    findChildren(item);
+                    results = (results || []).concat([item]);
+                }
+            }
+            parent[field_children] = results;
+        }
+    };
+    for (let i = 0, len = roots.length; i < len; ++i) {
+        findChildren(roots[i]);
+    }
+    if (index)
+        roots = roots[0];
+    if (roots && to_array) {
+        roots = yield (0, exports.treeToArray)([].concat(roots));
+    }
+    return roots;
+});
+exports.buildTree = buildTree;
+const expandTree = (items, { array = [], parent = null, level = 1, prefix = "-", field_index = "id", field_children = "children", key_value = "value" } = {}) => {
+    let str = new Array(level + 1).join(prefix) + " ";
+    items.forEach(item => {
+        let value = str + item[key_value];
+        if (item[field_children]) {
+            array.push(Object.assign(Object.assign({}, item), { parent, [field_children]: undefined, [key_value]: value, has_children: true }));
+            let parent_id = item[field_index];
+            return (0, exports.expandTree)(item[field_children], { array, parent: parent_id, level: level + 1, prefix, field_index, field_children, key_value });
+        }
+        else {
+            array.push(Object.assign(Object.assign({}, item), { parent, [key_value]: value, has_children: false }));
+        }
+    });
+    return array;
+};
+exports.expandTree = expandTree;
+const convertToBigEndian = (text) => {
+    let buffer = Buffer.from(text, 'ucs2');
+    let l = buffer.length;
+    if (l & 0x01) {
+        throw new Error('Buffer length must be even');
+    }
+    for (let i = 0; i < l; i += 2) {
+        let a = buffer[i];
+        buffer[i] = buffer[i + 1];
+        buffer[i + 1] = a;
+    }
+    return buffer.toString('hex');
+};
+exports.convertToBigEndian = convertToBigEndian;
+const slugify = (string = "", { lowercase = false } = {}) => {
+    if (!string || typeof (string) != 'string') {
+        return string;
+    }
+    if (lowercase) {
+        string = String(string).toLowerCase();
+    }
+    return String(string)
+        //.toLowerCase()
+        .replace(/[`~!@#$%^&*()|+=?;:'",.<>\{\}\[\]\\\/]/gi, '')
+        .replace(/\s+/g, '-')
+        .replace(/\-\-+/g, '-')
+        .replace(/^_+/, '')
+        .replace(/_+$/, '');
+};
+exports.slugify = slugify;
+const slugifyField = (string = "") => {
+    if (!string || typeof (string) != 'string') {
+        return string;
+    }
+    return String(string)
+        .toLowerCase()
+        .replace(/\s+/g, "_")
+        .replace(/[^a-zA-Z0-9:]/g, "_")
+        .replace(/\_\_+/g, "_")
+        .replace(/^_+/, '')
+        .replace(/_+$/, '');
+};
+exports.slugifyField = slugifyField;
+const stripHtml = (string) => {
+    if (!string || typeof (string) != 'string') {
+        return string;
+    }
+    return string
+        .replace(/<.*?>/g, '')
+        .replace(/\t/g, '')
+        .replace('&nbsp;', '')
+        .replace(/\n\n/g, ' ')
+        .replace(/\n/g, '');
+};
+exports.stripHtml = stripHtml;
+const replaceColon = (string, { decode = false } = {}) => {
+    if (!string || typeof (string) != 'string') {
+        return string;
+    }
+    let regex = /:/g, replace = "&#58;";
+    if (decode) {
+        regex = /&#58;/g, replace = ":";
+    }
+    return string.replace(regex, replace);
+};
+exports.replaceColon = replaceColon;
+const getParent = (nodes, { id = "", key_index = "id" } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    let obj = nodes.find(i => i[key_index] === Number(id));
+    if (obj) {
+        if (obj['parent'] === 0) {
+            return obj[key_index];
+        }
+        else {
+            return (0, exports.getParent)(nodes, { id: obj['parent'] });
+        }
+    }
+    return obj;
+});
+exports.getParent = getParent;
+const getDomain = (domain) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    return domain.replace(/^(?:https?:\/\/)?(?:www\.)?/i, "").split('/')[0];
+});
+exports.getDomain = getDomain;
+const getInstanceNumber = () => {
+    const key = (0, exports.getENV)('NODE_INSTANCE_KEY', 'NODE_APP_INSTANCE');
+    const split = (0, exports.getENV)('NODE_INSTANCE_SPLIT');
+    const index = (0, exports.getENV)('NODE_INSTANCE_INDEX');
+    let number = process.env[key];
+    if (split && number) {
+        let str = number.split(split);
+        if (str.length > 1)
+            number = str[index];
+    }
+    return number;
+};
+exports.getInstanceNumber = getInstanceNumber;
+const xorEncode = (str, key = '') => {
+    if (!key)
+        key = (0, exports.getENV)('ENCRYPTION_KEY', 'password');
+    key = crypto.createHash('md5').update(key).digest('hex');
+    let rand = '';
+    while (rand.length < 32) {
+        rand += String(Math.floor(Math.random() * (1000 * 1000 * 1000)));
+    }
+    rand = sha1(rand.substring(0, 32));
+    let enc = '';
+    for (let i = 0; i < str.length; i++) {
+        enc += String.fromCharCode(rand.charCodeAt(i % rand.length)) + String.fromCharCode(rand.charCodeAt(i % rand.length) ^ str.charCodeAt(i));
+    }
+    return Buffer.from((0, exports.xorMerge)(enc, key)).toString('base64');
+};
+exports.xorEncode = xorEncode;
+const xorDecode = (str, key = '') => {
+    if (!key)
+        key = (0, exports.getENV)('ENCRYPTION_KEY', 'password');
+    key = crypto.createHash('md5').update(key).digest('hex');
+    str = Buffer.from(str, 'base64').toString();
+    str = (0, exports.xorMerge)(str, key);
+    let dec = '';
+    for (let i = 0; i < str.length; i++) {
+        dec += String.fromCharCode(str.charCodeAt(i++) ^ str.charCodeAt(i));
+    }
+    return dec;
+};
+exports.xorDecode = xorDecode;
+const xorMerge = (str, key) => {
+    let hash = sha1(key);
+    let result = '';
+    for (let i = 0; i < str.length; i++) {
+        result += String.fromCharCode(str.charCodeAt(i) ^ hash.charCodeAt(i % hash.length));
+    }
+    return result;
+};
+exports.xorMerge = xorMerge;
+const convertCurrency = (data, currency = {}, { fields = [], fields_tax = [], fn_value = {}, fn_field = {}, fn_tax = {}, setting = false, vat_value = 0, tax_include = false, tax_dif = false, obj_format = {} } = {}) => {
+    let obj = {};
+    let exch_rate = Number(currency["exch_rate"] || 0) || 1;
+    let cur_format = currency["cur_format"] || "{{ price }} " + currency['title'];
+    let cur_decimal = currency['cur_decimal'] || "0";
+    let cur_format_num = currency['cur_format_num'] || "2";
+    if (currency['vat_value'] >= 0) {
+        vat_value = currency['vat_value'];
+    }
+    let tax_mod = 1 + (vat_value / 100);
+    let format = (currency['cur_comma'] != "0") ? '0,0' : '0';
+    let places = String("0").repeat(Number(cur_decimal));
+    format = format + "." + places;
+    let fnRound = Math.trunc;
+    let precision;
+    if (cur_format_num != "0") {
+        fnRound = Math.round;
+        if (cur_format_num == "2") {
+            precision = cur_decimal;
+        }
+    }
+    let obj_tax = {};
+    if (fields_tax.length) {
+        obj_tax = fields_tax.reduce((total, item) => (Object.assign(total, { [item]: true })), {});
+    }
+    for (let i = 0; i <= fields.length; i++) {
+        let field = fields[i];
+        let value = data[field];
+        if (fn_value[field] && typeof fn_value[field] == "function") {
+            value = fn_value[field](data);
+            data[field] = value;
+            obj_format[field] = true;
+        }
+        if (value >= 0) {
+            if (obj_tax[field]) {
+                data[field + '_tax'] = value;
+                if (!tax_include) {
+                    data[field + '_tax'] = Number((value * tax_mod).toFixed(5));
+                }
+                else {
+                    value = Number((value / tax_mod).toFixed(5));
+                    data[field] = value;
+                }
+                fields.push(field + '_tax');
+                obj_format[field + '_tax'] = true;
+                if (tax_dif) {
+                    data[field + '_tax_dif'] = data[field + '_tax'] - value;
+                    fields.push(field + '_tax_dif');
+                    obj_format[field + '_tax_dif'] = true;
+                }
+                if (fn_tax[field] && typeof fn_tax[field] == "function") {
+                    data[field + '_tax'] = fn_tax[field](data);
+                }
+            }
+            if (fn_field[field] && typeof fn_field[field] == "function") {
+                let option = fn_field[field](data);
+                if (option && option['key']) {
+                    data[option['key']] = option['value'] || 0;
+                    fields.push(option['key']);
+                    obj_format[option['key']] = true;
+                }
+            }
+            if (obj_format[field]) {
+                let _value = (Number(value).toFixed(5));
+                if (precision) {
+                    _value = _.round(_value, precision);
+                }
+                data[field] = Number(numeral(_value).format('0.' + places, fnRound));
+            }
+            value = ((Number(value) * exch_rate)).toFixed(5) + "";
+            if (precision) {
+                value = _.round(value, precision);
+            }
+            let formatted = numeral(value).format(format, fnRound);
+            obj[field] = formatted;
+            obj[field + "_formatted"] = cur_format.replace("{{ price }}", formatted);
+        }
+    }
+    ;
+    if (setting) {
+        obj = Object.assign({ cur_format, format, precision, cur_format_num }, obj);
+    }
+    return obj;
+};
+exports.convertCurrency = convertCurrency;

package/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from './core';
+export * from './config';
+export * from './auth';
+export * from './file';
+export * from './language';
+export * from './setting';
+export * from './stream';
+export * from './validator';
+export * from './user';
+export * from './currency';

package/utils/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./core"), exports);
+tslib_1.__exportStar(require("./config"), exports);
+tslib_1.__exportStar(require("./auth"), exports);
+tslib_1.__exportStar(require("./file"), exports);
+tslib_1.__exportStar(require("./language"), exports);
+tslib_1.__exportStar(require("./setting"), exports);
+tslib_1.__exportStar(require("./stream"), exports);
+tslib_1.__exportStar(require("./validator"), exports);
+tslib_1.__exportStar(require("./user"), exports);
+tslib_1.__exportStar(require("./currency"), exports);

package/utils/language.d.ts

@@ -0,0 +1,18 @@
+interface OptionLang {
+    organ_id?: string | number;
+    [index: string]: any;
+}
+export declare class LanguageUtil {
+    ref: string;
+    option: OptionLang;
+    constructor(ref: string, option?: OptionLang);
+    getLangsAll({ where }?: {
+        where?: {};
+    }): Promise<import("sequelize").Model<any, any>[]>;
+    getLangsLive({ where, attr_include }?: {
+        where?: {};
+        attr_include?: any[];
+    }): Promise<Array<any>>;
+    existLang(lang_code: string): Promise<0 | 1>;
+}
+export {};