@izara_project/izara-shared-search-and-sort 1.0.9 → 1.0.11

package/src/DataFieldsSharedLib.js

@@ -26,7 +26,7 @@ import { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
 const { isEmpty } = lodash;
 import filtersSharedLib from './FiltersSharedLib.js';
-import LogicalStructureSharedLib from './LogicalStructureSharedLib'
+import LogicalStructureSharedLib from './LogicalStructureSharedLib.js'
 
 async function createRequiredData(
   objType,
@@ -37,7 +37,7 @@ async function createRequiredData(
   perParentCombinations,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
-  values,
+  valueUserTags,
 ) {
   console.log('createRequiredData: ', {
     objType,
@@ -48,7 +48,7 @@ async function createRequiredData(
     perParentCombinations,
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
-    values,
+    valueUserTags,
   });
 
   let errorsObject = {};
@@ -73,12 +73,19 @@ async function createRequiredData(
     console.log('initial data: ', { linkSteps });
 
     let [fieldName, returnValue, linkPathErrorObject, linkPathErrorsFound] = await createLinkPath(
+      objType,
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
       perParentCombinations,
       complexFilterCombinations,
-      values,
+      valueUserTags,
+      {
+        objType: objType,
+        initialLogicalElementId: initialLogicalElementId,
+        logicalElements: logicalElements
+      },
+      [],
       errorsObject,
       errorsFound
     );
@@ -91,7 +98,14 @@ async function createRequiredData(
 
     if (linkPathErrorsFound.length > 0 || fieldName === null) {
       Object.assign(errorsObject, linkPathErrorObject);
-      errorsFound = errorsFound.concat(linkPathErrorsFound);
+
+      for (const linkPathErr of linkPathErrorsFound) {
+        if (!errorsFound.includes(linkPathErr)) {
+          errorsFound.push(linkPathErr);
+        }
+      }
+
+      // errorsFound = errorsFound.concat(linkPathErrorsFound);
       return {
         requiredDataHash: null,
         requiredDataObject: requiredDataObject,
@@ -133,17 +147,7 @@ async function createRequiredData(
         linkPathObjectId: pathId
       };
 
-      let requiredFieldNameObject = {
-        // fieldName: fieldName,
-        fieldName: setObject,
-        linkPathObjects: {
-          [pathId]: pathObject
-        },
-        linkPathSteps: returnValue.linkStepObjects
-      };
-
       if (returnValue.hasOwnProperty('complexFilterCombinations')) {
-        // requiredFieldNameObject.complexFilterCombinations = returnValue.complexFilterCombinations;
         Object.assign(setComplexFilterCombinations, returnValue.complexFilterCombinations);
 
         setObject.complexFilterCombinationIds = []
@@ -154,6 +158,15 @@ async function createRequiredData(
         };
       };
 
+      let requiredFieldNameObject = {
+        // fieldName: fieldName,
+        fieldName: setObject,
+        linkPathObjects: {
+          [pathId]: pathObject
+        },
+        linkPathSteps: returnValue.linkStepObjects
+      };
+
       if (returnValue.hasOwnProperty('perParentCombinations')) {
         // requiredFieldNameObject.perParentCombinations = returnValue.perParentCombinations;
         Object.assign(setPerParentCombinations, returnValue.perParentCombinations);
@@ -183,7 +196,11 @@ async function createRequiredData(
       console.log("------- requiredData has only fieldName ---------");
 
       let requiredFieldNameObject = {
-        fieldName: fieldName
+        fieldName: {
+          fieldName: fieldName
+        },
+        linkPathObjects: {},
+        linkPathSteps: {}
       };
       console.log("requiredFieldNameObject: ", requiredFieldNameObject);
 
@@ -215,17 +232,17 @@ async function createRequiredData(
     };
   };
 
-  if (!isEmpty(setComplexFilterCombinations)) {
-    requiredObject.complexFilterCombinations = setComplexFilterCombinations;
-  };
+  // if (!isEmpty(setComplexFilterCombinations)) {
+  //   requiredObject.complexFilterCombinations = setComplexFilterCombinations;
+  // };
 
-  if (!isEmpty(setPerParentCombinations)) {
-    requiredObject.perParentCombinations = setPerParentCombinations;
-  };
+  // if (!isEmpty(setPerParentCombinations)) {
+  //   requiredObject.perParentCombinations = setPerParentCombinations;
+  // };
 
-  if (!isEmpty(setFilterElementsLink)) {
-    requiredObject.filterElements = setFilterElementsLink;
-  };
+  // if (!isEmpty(setFilterElementsLink)) {
+  //   requiredObject.filterElements = setFilterElementsLink;
+  // };
   console.log('requiredObject: ', requiredObject);
 
   if (!isEmpty(requiredObject)) {
@@ -268,19 +285,18 @@ async function createRequiredData(
 
 
 async function createLinkPath(
+  objType,
   linkSteps,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   perParentCombinations,
   complexFilterCombinations,
-  values,
+  valueUserTags,
   filtersStructure,
   path,
   errorsObject,
   errorsFound,
-  index = 0,
-  previousLinkId = null,
-  previousLink = null
+  index = 0
 ) {
   console.log('create LinkPath: ', {
     linkSteps,
@@ -288,14 +304,12 @@ async function createLinkPath(
     requiredDataLinkSteps,
     perParentCombinations,
     complexFilterCombinations,
-    values,
+    valueUserTags,
     filtersStructure,
     path,
     errorsObject,
     errorsFound,
-    index,
-    previousLinkId,
-    previousLink
+    index
   });
   let fieldName = null;
   let returnValue = {}; //* must return only linkPath params
@@ -338,13 +352,14 @@ async function createLinkPath(
       // console.log('---------- is next link ----------', hhhh);
     }
 
-    let conditionsPromise = checkConditionsLink(
-      // let [conditions, conditionErrObject, conditionErrFound] = await this.checkConditionsLink(
+    // let conditionsPromise = checkConditionsLink(
+    let [conditions, conditionErrObject, conditionErrFound] = await checkConditionsLink(
       linkStep.pathLinkType.objType,
       linkStep,
       perParentCombinations,
       complexFilterCombinations,
-      values,
+      valueUserTags,
+      filtersStructure,
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
@@ -352,14 +367,20 @@ async function createLinkPath(
       errorsObject,
       errorsFound
     );
+    console.log('checkConditionsLink in link', {
+      conditions,
+      conditionErrObject,
+      conditionErrFound
+    });
 
     [fieldName, returnValue, errorsObject, errorsFound, sortObj] = await createLinkPath(
+      linkStep.pathLinkType.objType,
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
       perParentCombinations,
       complexFilterCombinations,
-      values,
+      valueUserTags,
       filtersStructure,
       path,
       errorsObject,
@@ -374,21 +395,25 @@ async function createLinkPath(
       index
     });
 
-    if (errorsFound.length > 0) {
-      return [null, null, errorsObject, errorsFound]
-    }
-
     console.log('linkStep', linkStep);
 
-    let [conditions, conditionErrObject, conditionErrFound] = await conditionsPromise;
-
+    // let [conditions, conditionErrObject, conditionErrFound] = await conditionsPromise;
     if (conditionErrFound.length > 0) {
       Object.assign(errorsObject, conditionErrObject);
-      errorsFound = errorsFound.concat(conditionErrFound);
 
-      return [null, null, errorsObject, errorsFound]
+      for (const conditionErr of conditionErrFound) {
+        if (!errorsFound.includes(conditionErr)) {
+          errorsFound.push(conditionErr);
+        }
+      }
+      // errorsFound = errorsFound.concat(conditionErrFound);
+      // return [null, null, errorsObject, errorsFound]
     };
 
+    if (errorsFound.length > 0) {
+      return [null, null, errorsObject, errorsFound];
+    }
+
     if (!isEmpty(returnValue)) {
       console.log('----------------- has returnValue ---------------------', { index, fieldName, returnValue, conditions })
 
@@ -397,13 +422,13 @@ async function createLinkPath(
       }
 
       if (conditions.hasOwnProperty('filterElements')) {
-        for (const filterElementId of Object.keys(conditions.filterElements)) {
+        for (const [filterElementId, filterElements] of Object.entries(conditions.filterElements)) {
           linkStepObject.filterElementId = filterElementId;
 
           if (returnValue.hasOwnProperty('filterElements')) {
-            Object.assign(returnValue['filterElements'], conditions.filterElements);
+            Object.assign(returnValue['filterElements'], filterElements);
           } else {
-            returnValue.filterElements = conditions.filterElements;
+            returnValue.filterElements = filterElements;// conditions.filterElements;
           }
         }
       }
@@ -422,7 +447,7 @@ async function createLinkPath(
       if (conditions.hasOwnProperty('linkPathObjects')) {
         if (conditions.hasOwnProperty('linkStepObjects')) {
 
-          linkStepObject.requiredDataFields = conditions.requiredDataFields;
+          linkStepObject.requiredDataObjects = conditions.requiredDataFields;
 
           if (returnValue.hasOwnProperty("sortFieldLinkPathObjects")) {
             Object.assign(returnValue.sortFieldLinkPathObjects["linkPathObjects"], conditions.linkPathObjects);
@@ -507,6 +532,19 @@ async function createLinkPath(
         };
       };
 
+      if (conditions.hasOwnProperty("comparison")) {
+        if (conditions.hasOwnProperty("comparisonSortField")) {
+          if (conditions.hasOwnProperty("comparisonValue")) {
+            if (conditions.hasOwnProperty('comparisonSortDataType')) {
+              linkStepObject.comparison = conditions.comparison;
+              linkStepObject.comparisonSortField = conditions.comparisonSortField;
+              linkStepObject.comparisonSortDataType = conditions.comparisonSortDataType;
+              linkStepObject.comparisonValue = conditions.comparisonValue;
+            }
+          }
+        }
+      }
+
       console.log('linkStepObject', linkStepObject);
       let linkStepId = hash(linkStepObject);
       console.log('linkStepId', linkStepId);
@@ -525,9 +563,9 @@ async function createLinkPath(
       };
 
       if (conditions.hasOwnProperty('filterElements')) {
-        for (const filterElementId of Object.keys(conditions.filterElements)) {
+        for (const [filterElementId, filterElements] of Object.entries(conditions.filterElements)) {
           linkStepObject.filterElementId = filterElementId;
-          returnValue.filterElements = conditions.filterElements;
+          returnValue.filterElements = filterElements;
         };
       };
 
@@ -545,7 +583,7 @@ async function createLinkPath(
       if (conditions.hasOwnProperty('linkPathObjects')) {
         if (conditions.hasOwnProperty('linkStepObjects')) {
 
-          linkStepObject.requiredDataFields = conditions.requiredDataFields;
+          linkStepObject.requiredDataObjects = conditions.requiredDataFields;
 
           if (returnValue.hasOwnProperty("sortFieldLinkPathObjects")) {
             Object.assign(returnValue.sortFieldLinkPathObjects["linkPathObjects"], conditions.linkPathObjects);
@@ -570,15 +608,32 @@ async function createLinkPath(
           if (conditions.hasOwnProperty("setFilterCombinations") && !isEmpty(conditions.setFilterCombinations)) {
 
             if (conditions.setFilterCombinations.hasOwnProperty('filterElements')) {
-              Object.assign(returnValue["filterElements"], conditions.setFilterCombinations.filterElements);
+              if (returnValue.hasOwnProperty("filterElements")) {
+                Object.assign(returnValue["filterElements"], conditions.setFilterCombinations.filterElements);
+              } else {
+                returnValue.filterElements = {}
+                Object.assign(returnValue["filterElements"], conditions.setFilterCombinations.filterElements);
+              }
             }
 
             if (conditions.setFilterCombinations.hasOwnProperty('perParentCombinations')) {
-              Object.assign(returnValue["perParentCombinations"], conditions.perParentCombinations);
+              // Object.assign(returnValue["perParentCombinations"], conditions.perParentCombinations);
+              if (returnValue.hasOwnProperty("perParentCombinations")) {
+                Object.assign(returnValue["perParentCombinations"], conditions.setFilterCombinations.perParentCombinations);
+              } else {
+                returnValue.perParentCombinations = {}
+                Object.assign(returnValue["perParentCombinations"], conditions.setFilterCombinations.perParentCombinations);
+              }
             };
 
             if (conditions.setFilterCombinations.hasOwnProperty('complexFilterCombinations')) {
-              Object.assign(returnValue['complexFilterCombinations'], conditions.complexFilterCombinations);
+              // Object.assign(returnValue['complexFilterCombinations'], conditions.complexFilterCombinations);
+              if (returnValue.hasOwnProperty("complexFilterCombinations")) {
+                Object.assign(returnValue["complexFilterCombinations"], conditions.setFilterCombinations.complexFilterCombinations);
+              } else {
+                returnValue.complexFilterCombinations = {}
+                Object.assign(returnValue["complexFilterCombinations"], conditions.setFilterCombinations.complexFilterCombinations);
+              }
             };
           }
 
@@ -608,12 +663,16 @@ async function createLinkPath(
         };
       };
 
+
       if (conditions.hasOwnProperty("comparison")) {
         if (conditions.hasOwnProperty("comparisonSortField")) {
           if (conditions.hasOwnProperty("comparisonValue")) {
-            linkStepObject.comparison = conditions.comparison;
-            linkStepObject.comparisonSortField = conditions.comparisonSortField;
-            linkStepObject.comparisonValue = conditions.comparisonValue;
+            if (conditions.hasOwnProperty('comparisonSortDataType')) {
+              linkStepObject.comparison = conditions.comparison;
+              linkStepObject.comparisonSortField = conditions.comparisonSortField;
+              linkStepObject.comparisonSortDataType = conditions.comparisonSortDataType;
+              linkStepObject.comparisonValue = conditions.comparisonValue;
+            }
           }
         }
       }
@@ -629,7 +688,7 @@ async function createLinkPath(
       console.log('returnValue', returnValue);
     }
   }
-  return [fieldName, returnValue, errorsObject, errorsFound]
+  return [fieldName, returnValue, errorsObject, errorsFound, sortObj]
 }
 
 
@@ -638,7 +697,7 @@ async function checkConditionsLink(
   linkStepObject,
   perParentCombinations,
   complexFilterCombinations,
-  values,
+  valueUserTags,
   filtersStructure,
   linkSteps,
   requiredDataLinkStepObjects,
@@ -652,7 +711,7 @@ async function checkConditionsLink(
     linkStepObject,
     perParentCombinations,
     complexFilterCombinations,
-    values,
+    valueUserTags,
     filtersStructure,
     linkSteps,
     requiredDataLinkStepObjects,
@@ -664,7 +723,8 @@ async function checkConditionsLink(
 
 
   let conditionLinkObject = {};
-  let filterMainRequest = null
+  let addFilterMainRequest = null;
+  let filterElements = null;
 
   if (linkStepObject.hasOwnProperty("addFilterMain") && linkStepObject.addFilterMain === true) {
 
@@ -687,7 +747,25 @@ async function checkConditionsLink(
       Object.assign(errorsObject, filterErrorObject);
       errorsFound = errorsFound.concat('filterErrorFound');
     } else {
-      filterMainRequest = filterStructureCurrent;
+
+      let [complexFilterRequest, status, filterErrorsObject, filterErrorsFound] = filtersSharedLib.createFiltersRequest(
+        filterStructureCurrent.objType,
+        filterStructureCurrent.initialLogicalElementId,
+        filterStructureCurrent.logicalElements,
+        valueUserTags
+      );
+      console.log('return complexFilter for filterElements: ', {
+        complexFilterRequest,
+        status,
+        filterErrorsObject,
+        filterErrorsFound
+      });
+
+      if (filterErrorsFound.length > 0) {
+        Object.assign(errorsObject, filterErrorsObject)
+        errorsFound = errorsFound.concat(filterErrorsFound)
+      };
+      addFilterMainRequest = complexFilterRequest;
     }
 
   }
@@ -695,35 +773,19 @@ async function checkConditionsLink(
   if (linkStepObject.hasOwnProperty('filterElements')) {
     console.log('------------ has filterElements ------------');
 
-    let filters = {};
-
-    if (filterMainRequest !== null) {
-      if (hash(filterMainRequest.objType) !== hash(linkStepObject.filterElements.objType)) {
-        errorsObject[linkStepObject.filterElements.objType.objectType] = 'this linkStep has error when combine filterMain in link';
-        errorsFound.push(`${linkStepObject.filterElements.objType.objectType}: this linkStep has error when combine filterMain in link`);
-        return [null, errorsObject, errorsFound];
-      }
-
-      filters = filtersSharedLib.combineLogicalElements(
-        filterMainRequest,
-        linkStepObject.filterElements
-      );
-
-
-    } else {
-      filters = {
-        objType: linkStepObject.filterElements.objType,
-        initialLogicalElementId: linkStepObject.filterElements.initialLogicalElementId,
-        logicalElements: linkStepObject.filterElements.logicalElements,
-      }
+    let filters = {
+      objType: linkStepObject.filterElements.objType,
+      initialLogicalElementId: linkStepObject.filterElements.initialLogicalElementId,
+      logicalElements: linkStepObject.filterElements.logicalElements,
     }
+
     console.log('filters: ', filters);
 
     let [complexFilterRequest, status, filterErrorsObject, filterErrorsFound] = filtersSharedLib.createFiltersRequest(
       filters.objType,
       filters.initialLogicalElementId,
       filters.logicalElements,
-      values
+      valueUserTags
     );
     console.log('return complexFilter for filterElements: ', {
       complexFilterRequest,
@@ -737,36 +799,55 @@ async function checkConditionsLink(
       errorsFound = errorsFound.concat(filterErrorsFound)
     };
 
-    conditionLinkObject.filterElements = complexFilterRequest.filterElements;
-    console.log('conditionLinkObject in condition link: ', conditionLinkObject);
+    filterElements = complexFilterRequest;
+  }
 
+  if (!conditionLinkObject.hasOwnProperty("filterElements")) {
+    conditionLinkObject.filterElements = {};
   }
 
+  if (addFilterMainRequest !== null) {
+    if (filterElements !== null) {
 
-  // if (linkStepObject.hasOwnProperty('filterElements')) {
-  //   console.log('------------ has filterElements ------------');
-
-  //   let [complexFilterRequest, status, filterErrorsObject, filterErrorsFound] = filtersSharedLib.createFiltersRequest(
-  //     linkStepObject.filterElements.objType,
-  //     linkStepObject.filterElements.initialLogicalElementId,
-  //     linkStepObject.filterElements.logicalElements,
-  //     values
-  //   );
-  //   console.log('return complexFilter for filterElements: ', {
-  //     complexFilterRequest,
-  //     status,
-  //     filterErrorsObject,
-  //     filterErrorsFound
-  //   });
-
-  //   if (filterErrorsFound.length > 0) {
-  //     Object.assign(errorsObject, filterErrorsObject)
-  //     errorsFound = errorsFound.concat(filterErrorsFound);
-  //     return [null, errorsObject, errorsFound]
-  //   };
-  //   conditionLinkObject.filterElements = complexFilterRequest.filterElements;
-  //   console.log('conditionLinkObject in condition link: ', conditionLinkObject);
-  // }
+      let combineLogicalElements = Object.assign(addFilterMainRequest.filterElements, filterElements.filterElements);
+      console.log('combineLogicalElements: ', combineLogicalElements);
+
+      // create new operation FilterObject
+      let operationFilterObject = {
+        objType: objType,
+        filterElement: {
+          filterType: "operation",
+          filterElements: combineLogicalElements,
+          filterElementLeft: addFilterMainRequest.filterMainId,
+          filterElementRight: filterElements.filterMainId,
+          operator: "AND"
+        }
+      }
+      console.log("operationFilterObject", operationFilterObject);
+
+      let operationFilterMainId = hash(operationFilterObject);
+      console.log("==== validate operationFilterMainId After Hash =====", operationFilterMainId);
+
+      delete operationFilterObject.filterElement.filterElements;
+
+      combineLogicalElements = Object.assign(combineLogicalElements, { [operationFilterMainId]: operationFilterObject });
+
+      conditionLinkObject.filterElements = {
+        [operationFilterMainId]: combineLogicalElements
+      };
+
+    } else {
+      conditionLinkObject.filterElements = {
+        [addFilterMainRequest.filterMainId]: addFilterMainRequest.filterElements
+      };
+    }
+  } else {
+    if (filterElements !== null) {
+      conditionLinkObject.filterElements = {
+        [filterElements.filterMainId]: filterElements.filterElements
+      };
+    }
+  }
 
   if (linkStepObject.hasOwnProperty('aggregate')) {
     console.log('------------ has aggregate ------------');
@@ -798,19 +879,23 @@ async function checkConditionsLink(
     for (const sortField of linkStepObject.sortFields) {
       console.log('sortField: ', sortField);
       console.log('requiredDataLinkSteps: ', requiredDataLinkSteps);
+      console.log('requiredDataLinkStepObjects: ', requiredDataLinkStepObjects);
       let requiredDataLinkStepSortField = requiredDataLinkStepObjects[sortField.requiredDataLinkStepObjectId];
       console.log('requiredDataLinkStepSortField: ', requiredDataLinkStepSortField);
-
-      console.log(' requiredDataLinkStepSortField.linkSteps: ', requiredDataLinkStepSortField.linkSteps);
+      console.log(' requiredDataLinkStepSortField.linkSteps: ', {
+        linkSteps: requiredDataLinkStepSortField.linkSteps,
+        requiredDataLinkStepSortField: requiredDataLinkStepSortField
+      });
 
       //* make all linkPath in here and send out to combine allLinkPath
-      let [fieldName, childLinkStep, linkErrorsObject, linkErrorsFound] = await createLinkPath(
+      let [fieldName, childLinkStep, linkErrorsObject, linkErrorsFound, sortObj] = await createLinkPath(
+        linkStepObject.pathLinkType.objType,
         requiredDataLinkStepSortField.linkSteps,
         requiredDataLinkStepObjects,
         requiredDataLinkSteps,
         perParentCombinations,
         complexFilterCombinations,
-        values,
+        valueUserTags,
         filtersStructure,
         [],
         errorsObject,
@@ -820,7 +905,8 @@ async function checkConditionsLink(
         fieldName,
         childLinkStep,
         linkErrorsObject,
-        linkErrorsFound
+        linkErrorsFound,
+        sortObj
       });
 
       if (linkErrorsFound > 0) {
@@ -874,7 +960,6 @@ async function checkConditionsLink(
         requiredDataFields.push({
           fieldName: fieldName,
           linkPathObjectId: pathId,
-          // dataType: sortField.dataType
         });
 
       } else {
@@ -883,15 +968,33 @@ async function checkConditionsLink(
         });
       };
 
+      if (!sortField.hasOwnProperty("dataType")) {
+        errorsFound.push(`${objType.objectType}: this sortField of linkStep  is not set dataType`);
+        errorsObject = {
+          [objType.objectType]: 'this sortField of linkStep  is not set dataType'
+        };
+        return [null, errorsObject, errorsFound]
+      }
+
       let sortObject = {
         fieldName: fieldName,
-        // dataType: sortField.dataType
+        dataType: sortField.dataType
       }
 
-      if (sortObj !== null) {
-        if (sortObj.dataType === "array") {
-          sortObject.dataType = sortObj.dataType
-          sortObject.values = sortObj.value;
+      if (sortField.dataType === "array") {
+
+        if (isEmpty(sortField.sortByValueUserTags)) {
+          errorsFound.push(`${objType.objectType}: sortField has sortByValueUserTags is empty`);
+          errorsObject = {
+            [objType.objectType]: 'sortField has sortByValueUserTags is empty'
+          }
+          return [null, errorsObject, errorsFound]
+        }
+
+        sortObject.values = [];
+        let sortArrays = sortField.sortByValueUserTags;
+        for (let sort of sortArrays) {
+          sortObject.values.push(valueUserTags[sort].value);
         }
       }
 
@@ -939,7 +1042,7 @@ async function checkConditionsLink(
 
     for (const [tag, requestPropertyId] of Object.entries(linkStepObject.requestProperties)) {
       console.log('extract requestProperties', { tag, requestPropertyId });
-      let requestPropertyObject = values[requestPropertyId];
+      let requestPropertyObject = valueUserTags[requestPropertyId];
       console.log('extract requestProperties', requestPropertyObject);
 
 
@@ -955,7 +1058,7 @@ async function checkConditionsLink(
             perParentCombinationObject.objType,
             perParentCombinationObject.initialLogicalElementId,
             perParentCombinationObject.logicalElements,
-            values,
+            valueUserTags,
           );
           console.log('return complexFilter for perParentCombinations: ', {
             complexFilterRequest,
@@ -996,7 +1099,7 @@ async function checkConditionsLink(
             complexFilterCombinationObject.objType,
             complexFilterCombinationObject.initialLogicalElementId,
             complexFilterCombinationObject.logicalElements,
-            values
+            valueUserTags
           );
           console.log('return complexFilter for complexFilterCombinations: ', {
             complexFilterRequest,
@@ -1016,7 +1119,6 @@ async function checkConditionsLink(
           applyCombinations.push({
             tag: tag,
             filterMainId: complexFilterRequest.filterMainId,
-            // identifiersFieldName: requestPropertyObject.identifierFieldName
           });
           console.log('applyCombinations: ', applyCombinations);
 
@@ -1027,7 +1129,6 @@ async function checkConditionsLink(
               filterElements: complexFilterRequest.filterElements
             }
           });
-          // Object.assign(perParentCombinationObjects, complexFilterRequest.filterElements);
         };
 
       } else {
@@ -1035,15 +1136,15 @@ async function checkConditionsLink(
         if (isEmpty(conditionLinkObject)) {
           conditionLinkObject = {
             requestProperties: {
-              [tag]: values[requestPropertyId].value
+              [tag]: valueUserTags[requestPropertyId].value
             }
           };
         } else {
           if (conditionLinkObject.hasOwnProperty('requestProperties')) {
-            conditionLinkObject.requestProperties[tag] = values[requestPropertyId].value;
+            conditionLinkObject.requestProperties[tag] = valueUserTags[requestPropertyId].value;
           } else {
             conditionLinkObject['requestProperties'] = {
-              [tag]: values[requestPropertyId].value
+              [tag]: valueUserTags[requestPropertyId].value
             };
           };
         };
@@ -1075,15 +1176,16 @@ async function checkConditionsLink(
   if (linkStepObject.hasOwnProperty("comparison")) {
     console.log('------------ link has comparison ------------');
 
-    if (!linkStepObject.hasOwnProperty("comparisonSortField") || !linkStepObject.hasOwnProperty("comparisonValue")) {
-      errorsObject[objType.objectType] = 'no comparisonSortField | comparisonValue';
-      errorsFound.push(`${objType.objectType}: no comparisonSortField | comparisonValue`);
+    if (!linkStepObject.hasOwnProperty('comparisonSortField') || !linkStepObject.hasOwnProperty('comparisonValue') || !linkStepObject.hasOwnProperty('comparisonSortDataType')) {
+      errorsObject[objType.objectType] = 'no comparisonSortField | comparisonValue | comparisonSortDataType';
+      errorsFound.push(`${objType.objectType}: no comparisonSortField | comparisonValue | comparisonSortDataType`);
       return [null, errorsObject, errorsFound]
     }
 
     conditionLinkObject.comparison = linkStepObject.comparison;
     conditionLinkObject.comparisonSortField = linkStepObject.comparisonSortField;
-    conditionLinkObject.comparisonValue = values[linkStepObject.comparisonValue].value;
+    conditionLinkObject.comparisonSortDataType = linkStepObject.comparisonSortDataType;
+    conditionLinkObject.comparisonValue = valueUserTags[linkStepObject.comparisonValue].value;
 
   }
 
@@ -1166,15 +1268,7 @@ function checkMultipleIdentifers(
   linkConfig = {},
   conditions = {},
   multipleIdentifiers = false,
-  //
 ) {
-  // conditions: {
-  //   aggregate ,
-  //   comparison,
-  //   combine ,
-  //   applyCombinations ,
-  //   multipleIdentifiers,
-  // }
 
   let manyIdentifiers = null;