drapcode-utility 1.0.0

package/build/utils/query-parser.js

@@ -0,0 +1,778 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMinMaxValue = exports.isEntityInCondition = exports.queryParser = void 0;
+var moment_1 = __importDefault(require("moment"));
+var drapcode_constant_1 = require("drapcode-constant");
+var date_util_1 = require("./date-util");
+var util_1 = require("./util");
+var queryParser = function (collectionName, query, constants, externalParams, currentUser, timezone, searchObj, refCollectionFieldsInItems, searchQueryTypeObj, currentTenant) {
+    if (currentUser === void 0) { currentUser = {}; }
+    if (searchObj === void 0) { searchObj = null; }
+    if (refCollectionFieldsInItems === void 0) { refCollectionFieldsInItems = null; }
+    if (searchQueryTypeObj === void 0) { searchQueryTypeObj = {}; }
+    if (currentTenant === void 0) { currentTenant = {}; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var filterQuery, aggregateQuery, queryStr, searchQueryObj, _a, searchAggregateQuery, likeQuery, finalQuery, _b, searchAggregateQuery, likeQuery, projection, finder, sortBy, orderBy, offset, limit, direction, str;
+        var _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    if (!collectionName)
+                        return [2 /*return*/, ""];
+                    if (!query)
+                        return [2 /*return*/, ""];
+                    console.log("***1*** queryParser ***");
+                    filterQuery = mongoFilterQuery(query, externalParams, constants, currentUser, currentTenant);
+                    console.log("**************************");
+                    console.log("filterQuery", JSON.stringify(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 = null;
+                        if (searchObj) {
+                            _a = getSearchObjQuery(searchObj, searchQueryTypeObj, timezone), searchAggregateQuery = _a.searchAggregateQuery, likeQuery = _a.likeQuery;
+                            aggregateQuery = __spreadArrays(aggregateQuery, searchAggregateQuery);
+                            if (likeQuery && likeQuery.length > 0) {
+                                searchQueryObj = likeQuery;
+                            }
+                        }
+                        finalQuery = { $and: filterQuery };
+                        if (searchQueryObj) {
+                            (_c = finalQuery.$and).push.apply(_c, searchQueryObj);
+                        }
+                        aggregateQuery.push({ $match: finalQuery });
+                    }
+                    else if (searchObj) {
+                        _b = getSearchObjQuery(searchObj, searchQueryTypeObj, timezone), searchAggregateQuery = _b.searchAggregateQuery, likeQuery = _b.likeQuery;
+                        aggregateQuery = __spreadArrays(aggregateQuery, searchAggregateQuery);
+                        if (likeQuery.length) {
+                            // aggregateQuery.push({ $match: { $or: likeQuery } });
+                            aggregateQuery.push({ $match: { $and: likeQuery } });
+                        }
+                    }
+                    console.log("==> query", query);
+                    projection = mongoSelectQuery(query);
+                    finder = query.finder, sortBy = query.sortBy, orderBy = query.orderBy;
+                    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:
+                    _e.sent();
+                    _e.label = 2;
+                case 2:
+                    if (finder != "COUNT" && !util_1.isEmpty(projection)) {
+                        aggregateQuery.push({ $project: projection });
+                    }
+                    if (finder === "COUNT") {
+                        aggregateQuery.push({ $group: { _id: null, count: { $sum: 1 } } });
+                    }
+                    offset = externalParams.offset || 0;
+                    limit = externalParams.limit || 20000;
+                    if (externalParams.pagination == "false") {
+                        limit = 0;
+                        sortBy = 0;
+                    }
+                    if (finder != "COUNT" && sortBy) {
+                        direction = orderBy && orderBy == "asc" ? 1 : -1;
+                        aggregateQuery.push({ $sort: (_d = {}, _d[sortBy] = direction, _d._id = 1, _d) });
+                    }
+                    if (finder != "COUNT" && limit) {
+                        aggregateQuery.push({ $skip: +offset }, { $limit: +limit });
+                    }
+                    console.log("==> aggregateQuery", aggregateQuery);
+                    queryStr = ".aggregate(" + JSON.stringify(aggregateQuery) + ", { collation: { locale: \"en\" } })";
+                    str = "req.db.collection('" + collectionName + "')" + queryStr;
+                    str += ".toArray()";
+                    return [2 /*return*/, str];
+            }
+        });
+    });
+};
+exports.queryParser = queryParser;
+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, currentTenant) {
+    if (currentUser === void 0) { currentUser = {}; }
+    if (currentTenant === void 0) { currentTenant = {}; }
+    var filterQuery = { $or0: [] };
+    var conditions = query.conditions;
+    var queryConjunctions = [];
+    conditions.forEach(function (queryObj, index) {
+        var query = queryObj.query, requiredExternal = queryObj.requiredExternal;
+        console.log("query :>> ", JSON.stringify(query));
+        var mongoQuery = queryToMongo(query, requiredExternal, externalParams, constants, currentUser, currentTenant);
+        console.log(":::::::::mongoQuery::::", JSON.stringify(mongoQuery));
+        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 mongoFilterQuery :>> ", filterQuery);
+    var hasAndQueryConjunction = queryConjunctions.includes("AND");
+    var resultQuery = modifyQuery(filterQuery, hasAndQueryConjunction);
+    console.log("=>> resultQuery :>> ", resultQuery);
+    console.log("=>> JSON.stringify(resultQuery) :>> ", JSON.stringify(resultQuery));
+    return resultQuery;
+};
+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.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.ts:303 ~ Object.entries ~ arr:", arr);
+    return arr;
+};
+var queryToMongo = function (query, requiredExternal, externalParams, constants, currentUser, currentTenant) {
+    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 = {}; }
+    if (currentTenant === void 0) { currentTenant = {}; }
+    var fieldValue = replaceExternalParams(query, requiredExternal, externalParams, constants, currentUser, currentTenant);
+    if (["undefined", "null", null, undefined, ""].includes(fieldValue)) {
+        //TODO: In case field is not present in old record then fieldValue is undefined
+        //TODO: In case of this, we assign some random string to avoid resulting all values
+        //TODO: This is use case in Spot Factor Project, where a new user with blank value able to see all records
+        //TODO: Discussed on meet
+        fieldValue = "random_string_since_field_not_present_" + moment_1.default(1318874398806).valueOf();
+    }
+    console.log("fieldValue queryToMongo 1", fieldValue);
+    var isDate = checkDate(fieldValue);
+    console.log("isDate queryToMongo 2", isDate);
+    var key = query.key, field = query.field, value = query.value, fieldType = query.fieldType;
+    if (isDate)
+        fieldValue = new Date(fieldValue);
+    console.log("fieldValue queryToMongo 1", fieldValue);
+    var condition = [
+        "dynamic_option",
+        "reference",
+        "static_option",
+        "belongsTo",
+    ].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 {
+            //TODO: Handle timezone here
+            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 = exports.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 isEntityInCondition = function (value) {
+    var isEntity = false;
+    if (value && Array.isArray(value)) {
+        value.forEach(function (val) {
+            if (typeof val === "string" || val instanceof String)
+                isEntity = val.startsWith("ENTITY::");
+        });
+    }
+    else {
+        if (value && (typeof value === "string" || value instanceof String))
+            isEntity = value.startsWith("ENTITY::");
+    }
+    return isEntity;
+};
+exports.isEntityInCondition = isEntityInCondition;
+var replaceExternalParams = function (query, requiredExternal, externalParams, constants, currentUser, currentTenant) {
+    var key = query.key, value = query.value, fieldType = query.fieldType;
+    if (fieldType &&
+        !requiredExternal &&
+        ["dynamic_option", "reference", "static_option", "belongsTo"].includes(fieldType)) {
+        return value === drapcode_constant_1.CURRENT_USER ? currentUser["uuid"] : 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 = [];
+        if (value && Array.isArray(value)) {
+            value.forEach(function (val) { return valueList_1.push(val); });
+            constants.forEach(function (constant) {
+                value.forEach(function (val) {
+                    if (val === constant.name)
+                        valueList_1.push(constant.value);
+                });
+            });
+        }
+        return valueList_1;
+    }
+    if (key === drapcode_constant_1.BETWEEN) {
+        var _a = exports.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)) {
+            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 = "", refCollectionField = "";
+        if (splitValues.length > 2) {
+            refCollection = splitValues[1];
+            refCollectionField = splitValues[2];
+        }
+        else if (splitValues.length === 2) {
+            refCollection = splitValues[0];
+            refCollectionField = splitValues[1];
+        }
+        else {
+            refCollection = splitValues[0];
+            refCollectionField = "";
+        }
+        console.log("refCollection", refCollection);
+        console.log("refCollectionField", refCollectionField);
+        console.log("first", refCollectionField && refCollection);
+        if (refCollection && refCollectionField) {
+            console.log("I have refCollection and Field");
+            if (refCollection === drapcode_constant_1.CURRENT_USER) {
+                return currentUser[refCollectionField];
+            }
+            else {
+                var refCollectionData = currentUser[refCollection];
+                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.includes(drapcode_constant_1.CURRENT_TENANT)) {
+        if (value === drapcode_constant_1.CURRENT_TENANT) {
+            return currentTenant["uuid"];
+        }
+        var splitValues = value.split("::");
+        console.log("splitValues", splitValues);
+        var refCollection = "", refCollectionField = "";
+        if (splitValues.length > 2) {
+            refCollection = splitValues[1];
+            refCollectionField = splitValues[2];
+        }
+        else if (splitValues.length === 2) {
+            refCollection = splitValues[0];
+            refCollectionField = splitValues[1];
+        }
+        else {
+            refCollection = splitValues[0];
+            refCollectionField = "";
+        }
+        console.log("\n refCollection", refCollection);
+        console.log("\n refCollectionField", refCollectionField);
+        if (refCollection && refCollectionField) {
+            console.log("I have refCollection and Field");
+            if (refCollection === "CURRENT_TENANT") {
+                return currentTenant[refCollectionField];
+            }
+            else {
+                var refCollectionData = currentTenant[refCollection];
+                console.log("\n refCollectionData", refCollectionData);
+                if (!refCollectionData)
+                    return "";
+                if (refCollectionData.length > 1)
+                    return "";
+                refCollectionData = refCollectionData[0];
+                return refCollectionData[refCollectionField];
+            }
+        }
+        //this means that data has to be match with currnet user field that is not ref type
+        if (refCollection)
+            return currentTenant[refCollection];
+        return currentTenant["uuid"];
+    }
+    if (drapcode_constant_1.DateConstant.some(function (cnst) { return value.includes(cnst); })) {
+        return getValueOfProjectConstant(value, {});
+    }
+    if (exports.isEntityInCondition(value)) {
+        var key_1 = value.replace("ENTITY::", "");
+        return externalParams[key_1] ? externalParams[key_1] : "";
+    }
+    //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: "" };
+    }
+};
+exports.getMinMaxValue = getMinMaxValue;
+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);
+};
+var getSearchObjQuery = function (searchObj, searchQueryTypeObj, timezone) {
+    var searchAggregateQuery = [];
+    var likeQuery = [];
+    Object.entries(searchObj).forEach(function (_a) {
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        var key = _a[0], value = _a[1];
+        if (value) {
+            var searchQueryTypeKey = searchQueryTypeObj[key];
+            if (searchQueryTypeKey) {
+                if (searchQueryTypeKey === "boolean") {
+                    // if input is string and db field type is boolean
+                    searchAggregateQuery.push({
+                        $addFields: (_b = {},
+                            _b["_" + key] = "$" + key,
+                            _b),
+                    });
+                    likeQuery.push((_c = {},
+                        _c["_" + key] = toBoolean(value),
+                        _c));
+                }
+                else if ([
+                    "static_option",
+                    "dynamic_option",
+                    "reference",
+                    "belongsTo",
+                ].includes(searchQueryTypeKey)) {
+                    // if input is string and db field type is array
+                    searchAggregateQuery.push({
+                        $addFields: (_d = {},
+                            _d["_" + key] = "$" + key,
+                            _d),
+                    });
+                    likeQuery.push((_e = {},
+                        _e["_" + key] = { $all: [value] },
+                        _e));
+                }
+                else if (searchQueryTypeKey === "tel") {
+                    // handling value when db field type is tel
+                    searchAggregateQuery.push({
+                        $addFields: (_f = {},
+                            _f["_" + key] = { $toString: "$" + key },
+                            _f),
+                    });
+                    likeQuery.push((_g = {},
+                        _g["_" + key] = {
+                            $regex: value.startsWith("+") ? value.replace("+", "") : value,
+                            $options: "i",
+                        },
+                        _g));
+                }
+                else if (searchQueryTypeKey === "number") {
+                    // handling value when db field type is Double/Int
+                    searchAggregateQuery.push({
+                        $addFields: (_h = {},
+                            _h["_" + key] = { $toString: { $toLong: "$" + key } },
+                            _h),
+                    });
+                    likeQuery.push((_j = {},
+                        _j["_" + key] = {
+                            $regex: value,
+                            $options: "i",
+                        },
+                        _j));
+                }
+                else if (["date", "createdAt"].includes(searchQueryTypeKey)) {
+                    if (key.startsWith("start_") || key.startsWith("end_")) {
+                        var fieldKey = key.replace("start_", "");
+                        fieldKey = fieldKey.replace("end_", "");
+                        searchAggregateQuery.push({
+                            $addFields: (_k = {},
+                                _k["_" + key] = { $toString: "$" + fieldKey },
+                                _k),
+                        });
+                        if (key.startsWith("start_")) {
+                            likeQuery.push((_l = {},
+                                _l["_" + key] = {
+                                    $gte: date_util_1.timezoneDateParse(value, false, true),
+                                },
+                                _l));
+                        }
+                        else if (key.startsWith("end_")) {
+                            likeQuery.push((_m = {},
+                                _m["_" + key] = {
+                                    $lt: date_util_1.timezoneDateParse(value, true),
+                                },
+                                _m));
+                        }
+                    }
+                }
+                else {
+                    // if input is string and db field type is number
+                    // converting db field to string first
+                    searchAggregateQuery.push({
+                        $addFields: (_o = {},
+                            _o["_" + key] = { $toString: "$" + key },
+                            _o),
+                    });
+                    likeQuery.push((_p = {},
+                        _p["_" + key] = {
+                            $regex: value,
+                            $options: "i",
+                        },
+                        _p));
+                }
+            }
+            else {
+                likeQuery.push((_q = {},
+                    _q[key] = {
+                        $regex: value,
+                        $options: "i",
+                    },
+                    _q));
+            }
+        }
+    });
+    console.log("==> searchAggregateQuery", JSON.stringify(searchAggregateQuery));
+    console.log("==> likeQuery", JSON.stringify(likeQuery));
+    return { searchAggregateQuery: searchAggregateQuery, likeQuery: likeQuery };
+};