drapcode-utility 1.0.0

package/build/utils/query-paser-new.js

@@ -0,0 +1,682 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryParserNew = void 0;
+var drapcode_constant_1 = require("drapcode-constant");
+var date_util_1 = require("./date-util");
+var util_1 = require("./util");
+var queryParserNew = function (collectionName, query, constants, externalParams, currentUser, timezone, searchObj, refCollectionFieldsInItems, searchQueryTypeObj) {
+    if (currentUser === void 0) { currentUser = {}; }
+    if (searchObj === void 0) { searchObj = null; }
+    if (refCollectionFieldsInItems === void 0) { refCollectionFieldsInItems = null; }
+    if (searchQueryTypeObj === void 0) { searchQueryTypeObj = {}; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var filterQuery, aggregateQuery, queryStr, searchQueryObj_1, finalQuery, likeQuery_1, projection, finder, sortBy, orderBy, aggregateFunctionField, offset, limit, direction, str;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!collectionName)
+                        return [2 /*return*/, ""];
+                    if (!query)
+                        return [2 /*return*/, ""];
+                    console.log("***1*** queryParserNew ***");
+                    filterQuery = mongoFilterQuery(query, externalParams, constants, currentUser);
+                    console.log("**************************");
+                    console.log("**************************");
+                    console.log("filterQuery", filterQuery);
+                    console.log("==> searchQueryTypeObj :>>", searchQueryTypeObj);
+                    aggregateQuery = [];
+                    queryStr = ".aggregate([])";
+                    if (filterQuery.length &&
+                        ((filterQuery[0].$or && filterQuery[0].$or.length) ||
+                            (filterQuery[0].$and && filterQuery[0].$and.length))) {
+                        searchQueryObj_1 = null;
+                        if (searchObj) {
+                            searchQueryObj_1 = [];
+                            Object.entries(searchObj).forEach(function (_a) {
+                                var _b, _c, _d;
+                                var key = _a[0], value = _a[1];
+                                if (value) {
+                                    if (searchQueryTypeObj[key]) {
+                                        aggregateQuery.push({
+                                            $addFields: (_b = {},
+                                                _b["_" + key] = { $toString: "$" + key },
+                                                _b),
+                                        });
+                                        searchQueryObj_1.push((_c = {},
+                                            _c["_" + key] = {
+                                                $regex: value,
+                                                $options: "i",
+                                            },
+                                            _c));
+                                    }
+                                    else {
+                                        searchQueryObj_1.push((_d = {},
+                                            _d[key] = {
+                                                $regex: value,
+                                                $options: "i",
+                                            },
+                                            _d));
+                                    }
+                                }
+                            });
+                        }
+                        finalQuery = { $and: filterQuery };
+                        if (searchQueryObj_1.length) {
+                            finalQuery.$and.push([searchQueryObj_1]);
+                        }
+                        aggregateQuery.push({ $match: finalQuery });
+                    }
+                    else if (searchObj) {
+                        likeQuery_1 = [];
+                        Object.entries(searchObj).forEach(function (_a) {
+                            var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                            var key = _a[0], value = _a[1];
+                            if (value) {
+                                if (searchQueryTypeObj[key]) {
+                                    if (searchQueryTypeObj[key] === "boolean") {
+                                        // if input is string and db field type is boolean
+                                        aggregateQuery.push({
+                                            $addFields: (_b = {},
+                                                _b["_" + key] = "$" + key,
+                                                _b),
+                                        });
+                                        likeQuery_1.push((_c = {},
+                                            _c["_" + key] = toBoolean(value),
+                                            _c));
+                                    }
+                                    else if (["static_option", "dynamic_option", "reference", "belongsTo"].includes(searchQueryTypeObj[key])) {
+                                        // if input is string and db field type is array
+                                        aggregateQuery.push({
+                                            $addFields: (_d = {},
+                                                _d["_" + key] = "$" + key,
+                                                _d),
+                                        });
+                                        likeQuery_1.push((_e = {},
+                                            _e["_" + key] = { $all: [value] },
+                                            _e));
+                                    }
+                                    else if (searchQueryTypeObj[key] === "tel") {
+                                        // handling value when db field type is tel
+                                        aggregateQuery.push({
+                                            $addFields: (_f = {},
+                                                _f["_" + key] = { $toString: "$" + key },
+                                                _f),
+                                        });
+                                        likeQuery_1.push((_g = {},
+                                            _g["_" + key] = {
+                                                $regex: value.startsWith("+") ? value.replace("+", "") : value,
+                                                $options: "i",
+                                            },
+                                            _g));
+                                    }
+                                    else if (searchQueryTypeObj[key] === "number") {
+                                        // handling value when db field type is Double/Int
+                                        aggregateQuery.push({
+                                            $addFields: (_h = {},
+                                                _h["_" + key] = { $toString: { $toLong: "$" + key } },
+                                                _h),
+                                        });
+                                        likeQuery_1.push((_j = {},
+                                            _j["_" + key] = {
+                                                $regex: value,
+                                                $options: "i",
+                                            },
+                                            _j));
+                                    }
+                                    else {
+                                        // if input is string and db field type is number
+                                        // converting db field to string first
+                                        aggregateQuery.push({
+                                            $addFields: (_k = {},
+                                                _k["_" + key] = { $toString: "$" + key },
+                                                _k),
+                                        });
+                                        likeQuery_1.push((_l = {},
+                                            _l["_" + key] = {
+                                                $regex: value,
+                                                $options: "i",
+                                            },
+                                            _l));
+                                    }
+                                }
+                                else {
+                                    likeQuery_1.push((_m = {},
+                                        _m[key] = {
+                                            $regex: value,
+                                            $options: "i",
+                                        },
+                                        _m));
+                                }
+                            }
+                        });
+                        console.log("==> aggregateQuery", aggregateQuery);
+                        console.log("==> likeQuery", likeQuery_1);
+                        if (likeQuery_1.length) {
+                            // aggregateQuery.push({ $match: { $or: likeQuery } });
+                            aggregateQuery.push({ $match: { $and: likeQuery_1 } });
+                        }
+                    }
+                    console.log("==> query", query);
+                    projection = mongoSelectQuery(query);
+                    finder = query.finder, sortBy = query.sortBy, orderBy = query.orderBy, aggregateFunctionField = query.aggregateFunctionField;
+                    if (!(finder != "COUNT" && refCollectionFieldsInItems)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, Promise.all(refCollectionFieldsInItems.map(function (field) {
+                            var _a, _b, _c;
+                            if (["reference", "multi_reference", "belongsTo"].includes(field.type)) {
+                                var collectionName_1 = field.refCollection
+                                    ? field.refCollection["collectionName"]
+                                    : null;
+                                if (collectionName_1) {
+                                    if (field.type === "belongsTo") {
+                                        aggregateQuery.push({
+                                            $lookup: {
+                                                from: "" + collectionName_1,
+                                                localField: field.fieldName,
+                                                foreignField: "uuid",
+                                                as: field.fieldName,
+                                            },
+                                        });
+                                        aggregateQuery.push({
+                                            $addFields: (_a = {},
+                                                _a["_$belongsToMetaData"] = field,
+                                                _a),
+                                        });
+                                    }
+                                    else {
+                                        aggregateQuery.push({
+                                            $lookup: {
+                                                from: "" + collectionName_1,
+                                                let: (_b = {}, _b["" + field.fieldName] = "$" + field.fieldName, _b),
+                                                pipeline: [
+                                                    {
+                                                        $match: {
+                                                            $expr: {
+                                                                $in: [
+                                                                    "$uuid",
+                                                                    {
+                                                                        $cond: {
+                                                                            if: {
+                                                                                $in: ["$$" + field.fieldName, ["", null]],
+                                                                            },
+                                                                            then: [],
+                                                                            else: { $ifNull: ["$$" + field.fieldName, []] },
+                                                                        },
+                                                                    },
+                                                                ],
+                                                            },
+                                                        },
+                                                    },
+                                                    {
+                                                        $lookup: {
+                                                            from: "user",
+                                                            let: { createdBy: "$createdBy" },
+                                                            pipeline: [
+                                                                {
+                                                                    $match: {
+                                                                        $expr: { $eq: ["$uuid", "$$createdBy"] },
+                                                                    },
+                                                                },
+                                                                { $project: { _id: 0, password: 0 } },
+                                                            ],
+                                                            as: "createdBy",
+                                                        },
+                                                    },
+                                                ],
+                                                as: field.fieldName,
+                                            },
+                                        });
+                                    }
+                                }
+                            }
+                            if (field.type === "createdBy")
+                                aggregateQuery.push({
+                                    $lookup: {
+                                        from: "user",
+                                        let: (_c = {}, _c["" + field.fieldName] = "$" + field.fieldName, _c),
+                                        pipeline: [
+                                            {
+                                                $match: { $expr: { $eq: ["$uuid", "$$" + field.fieldName] } },
+                                            },
+                                            { $project: { _id: 0, password: 0 } },
+                                        ],
+                                        as: field.fieldName,
+                                    },
+                                });
+                        }))];
+                case 1:
+                    _b.sent();
+                    _b.label = 2;
+                case 2:
+                    if (!["COUNT", "SUM", "AVG", "MIN", "MAX"].includes(finder) &&
+                        !util_1.isEmpty(projection)) {
+                        aggregateQuery.push({ $project: projection });
+                    }
+                    if (finder === "COUNT") {
+                        aggregateQuery.push({ $group: { _id: null, count: { $sum: 1 } } });
+                    }
+                    else if (finder === "SUM") {
+                        aggregateQuery.push({
+                            $group: { _id: null, total: { $sum: "$" + aggregateFunctionField } },
+                        });
+                    }
+                    else if (finder === "AVG") {
+                        aggregateQuery.push({
+                            $group: { _id: null, average: { $avg: "$" + aggregateFunctionField } },
+                        });
+                    }
+                    else if (finder === "MIN") {
+                        aggregateQuery.push({
+                            $group: { _id: null, minimum: { $min: "$" + aggregateFunctionField } },
+                        });
+                    }
+                    else if (finder === "MAX") {
+                        aggregateQuery.push({
+                            $group: { _id: null, maximum: { $max: "$" + aggregateFunctionField } },
+                        });
+                    }
+                    offset = externalParams.offset || 0;
+                    limit = externalParams.limit || 10;
+                    if (externalParams.pagination == "false") {
+                        limit = 0;
+                        sortBy = 0;
+                    }
+                    if (finder != "COUNT" && sortBy) {
+                        direction = orderBy && orderBy == "asc" ? 1 : -1;
+                        aggregateQuery.push({ $sort: (_a = {}, _a[sortBy] = direction, _a) });
+                    }
+                    if (finder != "COUNT" && limit) {
+                        aggregateQuery.push({ $skip: +offset }, { $limit: +limit });
+                    }
+                    console.log("==> aggregateQuery", JSON.stringify(aggregateQuery, null, 2));
+                    queryStr = ".aggregate(" + JSON.stringify(aggregateQuery) + ", { collation: { locale: \"en\" } })";
+                    str = "req.db.collection('" + collectionName + "')" + queryStr;
+                    str += ".toArray()";
+                    return [2 /*return*/, str];
+            }
+        });
+    });
+};
+exports.queryParserNew = queryParserNew;
+var toBoolean = function (value) {
+    if (!value) {
+        return false;
+    }
+    switch (value.toLocaleLowerCase()) {
+        case "true":
+        case "1":
+        case "on":
+        case "yes":
+            return true;
+        default:
+            return false;
+    }
+};
+var mongoFilterQuery = function (query, externalParams, constants, currentUser) {
+    if (currentUser === void 0) { currentUser = {}; }
+    var filterQuery = { $or0: [] };
+    var conditions = query.conditions;
+    var queryConjunctions = [];
+    conditions.forEach(function (queryObj, index) {
+        var query = queryObj.query, requiredExternal = queryObj.requiredExternal;
+        var mongoQuery = queryToMongo(query, requiredExternal, externalParams, constants, currentUser);
+        queryConjunctions.push(queryObj.conjunctionType);
+        if (queryObj.conjunctionType == "OR") {
+            var lastKey = Object.keys(filterQuery)[Object.keys(filterQuery).length - 1];
+            if (filterQuery[lastKey] && Array.isArray(filterQuery[lastKey])) {
+                filterQuery[lastKey].push(mongoQuery);
+            }
+            else {
+                filterQuery["$or" + index] = [mongoQuery];
+            }
+        }
+        else if (queryObj.conjunctionType == "AND") {
+            var lastKey = Object.keys(filterQuery)[Object.keys(filterQuery).length - 1];
+            if (filterQuery[lastKey] && Array.isArray(filterQuery[lastKey])) {
+                filterQuery[lastKey].push(mongoQuery);
+            }
+            else {
+                filterQuery["$and" + index] = [mongoQuery];
+            }
+        }
+        else {
+            filterQuery["$or" + index] = [mongoQuery];
+        }
+    });
+    console.log("==> *** filterQuery #2 :>> ", filterQuery);
+    var hasAndQueryConjunction = queryConjunctions.includes("AND");
+    return modifyQuery(filterQuery, hasAndQueryConjunction);
+};
+var mongoSelectQuery = function (query) {
+    if (query === void 0) { query = {}; }
+    var projection = {};
+    var fieldsInclude = query.fieldsInclude, fieldsExclude = query.fieldsExclude;
+    if (!fieldsExclude)
+        fieldsExclude = [];
+    if (fieldsInclude[0] === "*") {
+        fieldsExclude.map(function (field) {
+            if (field)
+                return (projection["" + field] = 0);
+        });
+    }
+    else {
+        fieldsInclude.map(function (field) {
+            if (field)
+                return (projection["" + field] = 1);
+        });
+    }
+    return projection;
+};
+var modifyQuery = function (obj, hasAndQueryConjunction) {
+    if (obj === void 0) { obj = {}; }
+    if (hasAndQueryConjunction === void 0) { hasAndQueryConjunction = false; }
+    var arr = [];
+    console.log("🚀 ~ file: query-parser-new.ts:294 ~ modifyQuery ~ hasAndQueryConjunction:", hasAndQueryConjunction);
+    Object.entries(obj).forEach(function (_a) {
+        var key = _a[0], value = _a[1];
+        if (hasAndQueryConjunction) {
+            arr.push({ $and: value });
+        }
+        else {
+            arr.push({ $or: value });
+        }
+    });
+    console.log("🚀 ~ file: query-parser-new.ts:303 ~ Object.entries ~ arr:", arr);
+    return arr;
+};
+var queryToMongo = function (query, requiredExternal, externalParams, constants, currentUser) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+    if (currentUser === void 0) { currentUser = {}; }
+    var fieldValue = replaceExternalParams(query, requiredExternal, externalParams, constants, currentUser);
+    var isDate = checkDate(fieldValue);
+    var key = query.key, field = query.field, value = query.value, fieldType = query.fieldType;
+    if (isDate)
+        fieldValue = new Date(fieldValue);
+    var condition = ["dynamic_option", "reference", "static_option"].includes(fieldType);
+    if (condition && key === drapcode_constant_1.EQUALS && !isDate) {
+        if (!Array.isArray(fieldValue)) {
+            fieldValue = [fieldValue];
+        }
+        return _a = {}, _a[field] = { $in: fieldValue || [] }, _a;
+    }
+    if (condition && key === drapcode_constant_1.NOT_EQUAL && !isDate) {
+        if (!Array.isArray(fieldValue)) {
+            fieldValue = [fieldValue];
+        }
+        return _b = {}, _b[field] = { $nin: fieldValue || [] }, _b;
+    }
+    if (condition && key === drapcode_constant_1.IS_NULL) {
+        return _c = {}, _c[field] = { $type: "array", $eq: [] }, _c;
+    }
+    if (condition && key === drapcode_constant_1.IS_NOT_NULL) {
+        return _d = {}, _d[field] = { $exists: true, $type: "array", $ne: [] }, _d;
+    }
+    if (key === drapcode_constant_1.IS_NOT_NULL)
+        return _e = {}, _e[field] = { $nin: [null, ""] }, _e;
+    if (key === drapcode_constant_1.IS_NULL)
+        return _f = {}, _f[field] = { $in: [null, ""] }, _f;
+    if (key === drapcode_constant_1.LIKE)
+        return _g = {}, _g[field] = { $regex: fieldValue, $options: "i" }, _g;
+    if (key === drapcode_constant_1.GREATER_THAN_EQUALS_TO)
+        return _h = {}, _h[field] = { $gte: isDate ? fieldValue : +fieldValue }, _h;
+    if (key === drapcode_constant_1.LESS_THAN_EQUALS_TO)
+        return _j = {}, _j[field] = { $lte: isDate ? fieldValue : +fieldValue }, _j;
+    if (key === drapcode_constant_1.LESS_THAN)
+        return _k = {}, _k[field] = { $lt: isDate ? fieldValue : +fieldValue }, _k;
+    if (key === drapcode_constant_1.GREATER_THAN)
+        return _l = {}, _l[field] = { $gt: isDate ? fieldValue : +fieldValue }, _l;
+    if (key === drapcode_constant_1.IN_LIST) {
+        if (!Array.isArray(fieldValue)) {
+            fieldValue = [fieldValue];
+        }
+        return _m = {}, _m[field] = { $in: fieldValue || [] }, _m;
+    }
+    if (key === drapcode_constant_1.NOT_IN_LIST) {
+        if (!Array.isArray(fieldValue)) {
+            fieldValue = [fieldValue];
+        }
+        return _o = {}, _o[field] = { $nin: fieldValue || [] }, _o;
+    }
+    if (key === drapcode_constant_1.EQUALS && isDate) {
+        if (drapcode_constant_1.DateConstant.some(function (cnst) { return value.includes(cnst); }))
+            return _p = {},
+                _p[field] = {
+                    $gte: fieldValue,
+                },
+                _p;
+        else
+            return _q = {},
+                _q[field] = {
+                    $gte: fieldValue,
+                    $lt: new Date(date_util_1.nextDayDate(fieldValue)),
+                },
+                _q;
+    }
+    if (key == drapcode_constant_1.EQUALS && field === "createdBy")
+        return {
+            $and: [
+                (_r = {}, _r[field] = { $ne: null }, _r),
+                (_s = {}, _s[field] = { $ne: "" }, _s),
+                (_t = {}, _t[field] = { $eq: fieldValue }, _t),
+            ],
+        };
+    if (key == drapcode_constant_1.EQUALS && fieldType === "boolean" && fieldValue)
+        return JSON.parse(fieldValue)
+            ? (_u = {},
+                _u[field] = JSON.parse(fieldValue),
+                _u) : {
+            $or: [
+                (_v = {}, _v[field] = JSON.parse(fieldValue), _v),
+                (_w = {}, _w[field] = { $exists: false }, _w),
+            ],
+        };
+    if (key == drapcode_constant_1.EQUALS)
+        return _x = {},
+            _x[field] = fieldType === "boolean" && fieldValue
+                ? JSON.parse(fieldValue)
+                : !isNaN(fieldValue)
+                    ? +fieldValue
+                    : fieldValue,
+            _x;
+    if (key == drapcode_constant_1.NOT_EQUAL)
+        return _y = {},
+            _y[field] = {
+                $ne: fieldType === "boolean" && fieldValue
+                    ? JSON.parse(fieldValue)
+                    : fieldValue,
+            },
+            _y;
+    if (key == drapcode_constant_1.BETWEEN) {
+        var _0 = getMinMaxValue(fieldValue), startValue = _0.startValue, endValue = _0.endValue, isInteger = _0.isInteger;
+        return _z = {},
+            _z[field] = {
+                $gte: isInteger ? +startValue : startValue,
+                $lte: isInteger ? +endValue : endValue,
+            },
+            _z;
+    }
+};
+var replaceExternalParams = function (query, requiredExternal, externalParams, constants, currentUser) {
+    var key = query.key, value = query.value, fieldType = query.fieldType;
+    if (fieldType &&
+        !requiredExternal &&
+        ["dynamic_option", "static_option", "reference"].includes(fieldType)) {
+        return value;
+    }
+    if (fieldType &&
+        fieldType === "boolean" &&
+        ["true", "false", "", true, false].includes(value)) {
+        return "" + value;
+    }
+    if (key === drapcode_constant_1.IN_LIST || key === drapcode_constant_1.NOT_IN_LIST) {
+        var valueList_1 = [];
+        constants.forEach(function (constant) {
+            if (value && Array.isArray(value)) {
+                value.forEach(function (val) {
+                    if (val === constant.name) {
+                        valueList_1.push(constant.value);
+                    }
+                    else
+                        valueList_1.push(val);
+                });
+            }
+        });
+        return valueList_1;
+    }
+    if (key === drapcode_constant_1.BETWEEN) {
+        var _a = getMinMaxValue(value), startValue_1 = _a.startValue, endValue_1 = _a.endValue, isInteger = _a.isInteger;
+        if (requiredExternal) {
+            startValue_1 = "" + externalParams[startValue_1];
+            endValue_1 = "" + externalParams[endValue_1];
+        }
+        else {
+            if (__spreadArrays([drapcode_constant_1.CURRENT_USER], drapcode_constant_1.DateConstant).some(function (cnst) {
+                return startValue_1.includes(cnst);
+            })) {
+                startValue_1 = getValueOfProjectConstant(startValue_1, currentUser);
+            }
+            else {
+                startValue_1 = constants.filter(function (constant) { return constant.name == startValue_1; });
+            }
+            if (__spreadArrays([drapcode_constant_1.CURRENT_USER], drapcode_constant_1.DateConstant).some(function (cnst) { return endValue_1.includes(cnst); })) {
+                endValue_1 = getValueOfProjectConstant(endValue_1, currentUser);
+            }
+            else {
+                endValue_1 = constants.filter(function (constant) { return constant.name == endValue_1; });
+            }
+        }
+        //TODO: Need to test constant from collection and when this below if will run
+        if (Array.isArray(startValue_1)) {
+            startValue_1 = startValue_1[0].value;
+        }
+        if (Array.isArray(endValue_1)) {
+            endValue_1 = endValue_1[0].value;
+        }
+        //TODO: Need to figure out the params should be treated as number/string
+        if (!isNaN(startValue_1)) {
+            console.log("I am Number");
+            return startValue_1 + "---" + endValue_1 + "^";
+        }
+        else
+            return startValue_1 + "---" + endValue_1;
+    }
+    console.log("==> value", value);
+    console.log("==> currentUser", currentUser);
+    if (value.includes(drapcode_constant_1.CURRENT_USER)) {
+        if (value === drapcode_constant_1.CURRENT_USER) {
+            return currentUser["uuid"];
+        }
+        var splitValues = value.split("::");
+        console.log("splitValues", splitValues);
+        var refCollection = splitValues[1];
+        var refCollectionField = splitValues[2];
+        if (refCollection && refCollectionField) {
+            console.log("I have refCollection and Field");
+            var refCollectionData = currentUser[refCollection];
+            console.log("refCollectionData", refCollectionData);
+            if (!refCollectionData) {
+                return "";
+            }
+            if (refCollectionData.length > 1) {
+                //TODO: Need to handle multi ref
+                return "";
+            }
+            refCollectionData = refCollectionData[0];
+            console.log("refCollectionData[refCollectionField]", refCollectionData[refCollectionField]);
+            return refCollectionData[refCollectionField];
+        }
+        //this means that data has to be match with currnet user field that is not ref type
+        if (refCollection) {
+            return currentUser[refCollection];
+        }
+        return currentUser["uuid"];
+    }
+    if (value === drapcode_constant_1.CURRENT_USER) {
+        return currentUser["uuid"];
+    }
+    if (drapcode_constant_1.DateConstant.some(function (cnst) { return value.includes(cnst); })) {
+        return getValueOfProjectConstant(value, {});
+    }
+    //TODO: This is just to confirm if external then it should be get from externalParams
+    if (requiredExternal) {
+        //TODO: Value returns from here undefined.
+        var externalParamValue = externalParams["" + value];
+        if (!isNaN(externalParamValue)) {
+            return +externalParamValue;
+        }
+        return externalParams["" + value];
+    }
+    var constantArr = constants.filter(function (constant) { return constant.name == value; });
+    return constantArr.length ? "" + constantArr[0].value : "";
+};
+var checkDate = function (queryValue) {
+    return ("" + queryValue).match(date_util_1.DATE_REGEX);
+};
+var getMinMaxValue = function (value) {
+    var isValid = value && value.includes("---");
+    if (isValid) {
+        var isInteger = value.includes("^");
+        var result = value.split("---");
+        var endValue = result[1];
+        if (isInteger && result.length)
+            endValue = endValue.slice(0, -1);
+        return { startValue: result[0], endValue: endValue, isInteger: isInteger };
+    }
+    else {
+        return { startValue: "", endValue: "" };
+    }
+};
+//TODO: need to fix for all app constant with these
+var getValueOfProjectConstant = function (value, currentUser) {
+    if (value === drapcode_constant_1.CURRENT_USER)
+        return currentUser["uuid"];
+    if (value === drapcode_constant_1.CURRENT_DATE)
+        return date_util_1.createLoggerDateFormat();
+    if ([drapcode_constant_1.CURRENT_TIME, drapcode_constant_1.CURRENT_DATE_TIME].includes(value))
+        return date_util_1.createLogsDateFormat();
+    if (drapcode_constant_1.DateTimeUnit.some(function (cnst) { return value.includes(cnst); }))
+        return date_util_1.getDateValue(value);
+};