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

package/src/FiltersSharedLib.js

@@ -22,92 +22,30 @@ import lodash from 'lodash';
 import objectHash from 'object-hash';
 const { isEmpty } = lodash;
 
-function validateFilterElement(
-  filterElements,
-  logicalElements
-) {
-  let validate = false;
-  let countsBracket = 0;
-  let operationCounts = 0;
-  let logicalCounts = 0;
-  for (let logicalElement of Object.values(logicalElements)) {
-    if (logicalElement.logicalElementType === "openBracket" || logicalElement.logicalElementType === "closeBracket") {
-      countsBracket = countsBracket + 1;
-    } else if (logicalElement.logicalElementType === "operation") {
-      operationCounts = operationCounts + 1;
-    } else if (logicalElement.logicalElementType === "logical"
-      || logicalElement.logicalElementType === "childComplexFilter"
-      || logicalElement.logicalElementType === "identifiers"
-      || logicalElement.logicalElementType === "translateIds"
-      || logicalElement.logicalElementType === "traversal"
-    ) {
-      logicalCounts = logicalCounts + 1;
-    }
-  }
-  let logicalElementsLength = logicalCounts + operationCounts;
-  let filtersLength = Object.keys(filterElements).length;
-  console.log('check count: ', {
-    countsBracket,
-    operationCounts,
-    logicalCounts,
-    logicalElementsLength,
-    filtersLength
-  });
-
-  if (filtersLength === logicalElementsLength) {
-    validate = true;
-  }
-  return validate
-}
+const MAX_LOGICALS = 50;
 
 function createFiltersRequest(
   objType,
   initialLogicalElementId,
   logicalElements,
-  values,
+  valueUserTags,
 ) {
   console.log('createFiltersRequest: ', {
     objType,
     initialLogicalElementId,
     logicalElements,
-    values,
+    valueUserTags,
   });
 
   let filterMainId = null;
   let filterMainObject = {};
-  let operation = null;
+  // let operation = null;
   let nextFilterElementId = null;
 
   let errorsObject = {};
   let errorsFound = [];
   let status = 'valid';
 
-  // //* validate combine logicalStructure
-  // let [validateObject, validateFilterMainId, validateFilterObject, validateErrorsObject, validateErrors] = validateCombinationStructure(
-  //   objType,
-  //   initialLogicalElementId,
-  //   logicalElements,
-  //   values
-  // );
-  // console.log('return validateCombinationStructure: ', {
-  //   validateObject,
-  //   validateFilterMainId,
-  //   validateFilterObject,
-  //   validateErrorsObject,
-  //   validateErrors
-  // });
-
-  // if (!validateObject || validateErrors.length > 0) {
-  //   Object.assign(errorsObject, validateErrorsObject);
-  //   errorsFound = errorsFound.concat(validateErrors);
-  //   return [
-  //     null,
-  //     'invalid',
-  //     errorsObject,
-  //     errorsFound
-  //   ];
-  // };
-
   let operationErrorsObject = {};
   let operationErrors = [];
   let returnFilterElements = {};
@@ -115,22 +53,19 @@ function createFiltersRequest(
   [
     filterMainId,
     filterMainObject,
-    operation,
     operationErrorsObject,
     operationErrors,
-    nextFilterElementId,
     returnFilterElements
   ] = filterLogicalElements(
     objType,
     initialLogicalElementId,
     logicalElements,
-    values,
+    valueUserTags,
   );
 
   console.log('final return filterLogicalElements: ', {
     filterMainId,
     filterMainObject,
-    operation,
     operationErrorsObject,
     operationErrors,
     nextFilterElementId,
@@ -149,10 +84,8 @@ function createFiltersRequest(
   };
 
   let filterElements = {};
-  // if (filterMainObject.filterElement.hasOwnProperty('filterElements') || isEmpty(returnFilterElements)) {
   if (!isEmpty(returnFilterElements)) {
     filterElements = returnFilterElements;
-    Object.assign(filterElements, { [filterMainId]: filterMainObject });
   };
 
   if (isEmpty(filterElements)) {
@@ -181,13 +114,13 @@ function validateCombinationStructure(
   objType,
   initialLogicalElementId,
   logicalElements,
-  values
+  valueUserTags
 ) {
   console.log('validateCombinationStructure: ', {
     objType,
     initialLogicalElementId,
     logicalElements,
-    values
+    valueUserTags
   });
 
   let validateObject = true;
@@ -225,7 +158,6 @@ function validateCombinationStructure(
 
     if (logicalElementType === 'operation') {
       console.log('----------------- operation --------------');
-      console.log('logicalElementObject: ', logicalElementObject);
 
       lastOperation = logicalElementObject.operation;
       console.log('lastOperation: ', lastOperation);
@@ -252,7 +184,7 @@ function validateCombinationStructure(
         objType,
         logicalElementObject.nextLogicalElementId,
         logicalElements,
-        values
+        valueUserTags
       );
       console.log('return validateCombinationStruce for openBracket: ', {
         validateObject,
@@ -295,9 +227,9 @@ function validateCombinationStructure(
         errorsObject[logicalElementId] = `this logical structure is not set comparison`;
         errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set comparison`);
       };
-      if (!logicalElementObject.hasOwnProperty('value')) {
-        errorsObject[logicalElementId] = `this logical structure is not set value`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set value`);
+      if (!logicalElementObject.hasOwnProperty('valueUserTag')) {
+        errorsObject[logicalElementId] = `this logical structure is not set valueUserTag`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set valueUserTag`);
       };
 
       currentFilterMainId = logicalElementId;
@@ -342,7 +274,7 @@ function validateCombinationStructure(
         logicalElementObject.pathLinkType.objType,
         logicalElementObject.childLogicalElementId,
         logicalElements,
-        values
+        valueUserTags
       );
       console.log('return validateCombinationStruce for childComplexFilter: ', {
         childValidate,
@@ -409,9 +341,9 @@ function validateCombinationStructure(
         errorsObject[logicalElementId] = `this logical structure is not set comparison`;
         errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set comparison`);
       };
-      if (!logicalElementObject.hasOwnProperty('value')) {
-        errorsObject[logicalElementId] = `this logical structure is not set value`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set value`);
+      if (!logicalElementObject.hasOwnProperty('valueUserTag')) {
+        errorsObject[logicalElementId] = `this logical structure is not set valueUserTag`;
+        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set valueUserTag`);
       };
 
       currentFilterMainId = logicalElementId;
@@ -485,115 +417,6 @@ function validateCombinationStructure(
 
 }
 
-// function validateOperation(
-//   // _izContext,
-//   runningFilterMainId,
-//   runningFilterObject,
-//   lastOperation,
-//   currentFilterMainId,
-//   currentFilterObject,
-// ) {
-//   console.log('validateOperation: ', {
-//     runningFilterMainId,
-//     runningFilterObject,
-//     lastOperation,
-//     currentFilterMainId,
-//     currentFilterObject,
-//   });
-
-//   let errorsObject = {};
-//   let errorsFound = [];
-
-//   if (!currentFilterObject) {
-//     errorsObject[currentFilterMainId] = 'cannot found current filterElement object';
-//     errorsFound.push(`${currentFilterMainId}: cannot found current filterElement object`);
-//     return [null, null, errorsObject, errorsFound];
-//   };
-
-//   if (!runningFilterObject) {
-//     return [currentFilterMainId, currentFilterObject, errorsObject, errorsFound];
-//   };
-
-//   if (!lastOperation) {
-
-//     let returnNextElementId = null;
-//     let returnNextElementObject = null;
-
-//     if (runningFilterObject.logicalElementType === 'openBracket') {
-//       if (currentFilterObject.logicalElementType === 'closeBracket') {
-
-//         errorsObject[currentFilterMainId] = `this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`;
-//         errorsFound.push(`${currentFilterMainId}: this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`);
-
-//       } else {
-
-//         runningFilterObject.nextLogicalElementId = currentFilterMainId;
-//         currentFilterObject.previousLogicalElementId = runningFilterMainId;
-
-//         operations = Object.assign(runningFilterObject, currentFilterObject);
-
-//         _izContext.logger.debug('operations: ', operations);
-//         returnNextElementId = currentFilterMainId;
-//         returnNextElementObject = currentFilterObject;
-
-//       };
-
-//     } else if (runningFilterObject.logicalElementType === 'closeBracket') {
-//       if (currentFilterObject.logicalElementType === "closeBracket") {
-
-//         runningFilterObject.nextLogicalElementId = currentFilterMainId;
-//         currentFilterObject.previousLogicalElementId = runningFilterMainId;
-
-//         operations = Object.assign(runningFilterObject, currentFilterObject);
-//         _izContext.logger.debug('operations: ', operations);
-
-//         returnNextElementId = currentFilterMainId;
-//         returnNextElementObject = currentFilterObject;
-
-//       } else {
-//         errorsObject[currentFilterMainId] = `this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`;
-//         errorsFound.push(`${currentFilterMainId}: this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`);
-//       };
-
-//     } else {
-
-//       if (currentFilterObject.logicalElementType === 'closeBracket') {
-
-//         runningFilterObject.nextLogicalElementId = currentFilterMainId;
-//         currentFilterObject.previousLogicalElementId = runningFilterMainId;
-
-//         operations = Object.assign(runningFilterObject, currentFilterObject);
-//         _izContext.logger.debug('operations: ', operations);
-
-//         returnNextElementId = currentFilterMainId;
-//         returnNextElementObject = nextLogicalElementObject;
-//       } else {
-//         errorsObject[currentFilterMainId] = `this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`;
-//         errorsFound.push(`${currentFilterMainId}: this path has logicalElementType: ${runningFilterObject.logicalElementType} and ${currentFilterObject.logicalElementType} are error`);
-//       };
-//     };
-
-//     return [returnNextElementId, returnNextElementObject, errorsObject, errorsFound];
-
-//   };
-
-//   if (runningFilterMainId && lastOperation && currentFilterMainId) {
-
-//     // let operationFilterObject = {
-//     //   runningFilterMainId: runningFilterObject,
-//     //   operation: lastOperation,
-//     //   currentFilterMainId: currentFilterObject
-//     // };
-//     // // let operationFilterMainId = hash(operationFilterObject);
-
-//     return [currentFilterMainId, currentFilterObject, errorsObject, errorsFound];
-
-//   } else {
-//     errorsFound.push("found some error that not expect");
-//     return [null, null, errorsObject, errorsFound];
-//   };
-// };
-
 function validateOperation(
   objType,
   runningFilterMainId,
@@ -601,6 +424,7 @@ function validateOperation(
   lastLogicalOperator,
   currentFilterMainId,
   currentFilterObject,
+  filterElements
 ) {
   try {
 
@@ -611,6 +435,7 @@ function validateOperation(
       lastLogicalOperator: lastLogicalOperator,
       currentFilterMainId: currentFilterMainId,
       currentFilterObject: currentFilterObject,
+      filterElements: filterElements
     });
 
     let errorsFound = []
@@ -624,29 +449,48 @@ function validateOperation(
     if (!currentFilterObject) {
       console.log("validateOperation expected currentFilterObject not found");
       errorsFound.push("validateOperation expected currentFilterObject not found");
-      return [currentFilterMainId, null, null, errorsFound];
+      return [currentFilterMainId, null, errorsFound];
     }
     // if runningFilterObject set we should always have lastLogicalOperator
     if (runningFilterObject && !lastLogicalOperator) {
       console.log("validateOperation expected lastLogicalOperator not found");
       errorsFound.push("validateOperation expected lastLogicalOperator not found");
-      return [currentFilterMainId, currentFilterObject, null, errorsFound];
+      return [currentFilterMainId, currentFilterObject, errorsFound];
     }
 
     // check if is an operation, if not simply return currentFilterMainId
     if (!runningFilterObject || !lastLogicalOperator) {
       console.log("+++ validate no operation, R E T U R N  currentFilterMainId ++");
-      let filterElements = currentFilterObject.filterElement.filterElements;
-      delete currentFilterObject.filterElement.filterElements;
-      return [currentFilterMainId, currentFilterObject, null, errorsFound, filterElements];
+
+      let filterElements = {};
+      if (currentFilterObject.filterElement.filterType === "childComplexFilter") {
+        filterElements = currentFilterObject.filterElement.filterElements;
+        delete currentFilterObject.filterElement.filterElements;
+      } else if (currentFilterObject.filterElement.filterType === "logical") {
+        filterElements = {
+          [currentFilterMainId]: currentFilterObject
+        }
+      }
+
+      return [currentFilterMainId, currentFilterObject, errorsFound, filterElements];
     }
 
-    let filterElements = splitFilterElements(
-      runningFilterMainId,
-      runningFilterObject,
-      currentFilterMainId,
-      currentFilterObject
-    );
+    // let filterElements = splitFilterElements(
+    //   runningFilterMainId,
+    //   runningFilterObject,
+    //   currentFilterMainId,
+    //   currentFilterObject
+    // );
+
+    if (currentFilterObject.filterElement.filterType === "childComplexFilter") {
+      Object.assign(filterElements, currentFilterObject.filterElement.filterElements)
+      delete currentFilterObject.filterElement.filterElements;
+    } else if (currentFilterObject.filterElement.filterType === "logical") {
+      Object.assign(filterElements, {
+        [currentFilterMainId]: currentFilterObject
+      });
+
+    }
 
     console.log("----------------------------------------------------- filterElements", filterElements);
 
@@ -671,13 +515,13 @@ function validateOperation(
     console.log("RETURN validate operationFilterObject ==>", operationFilterObject);
     console.log("========= [validateOperation ::: End] =======");
 
-    let operation = {
-      filterMainIdA: runningFilterMainId,
-      operator: lastLogicalOperator,
-      filterMainIdB: currentFilterMainId,
-    };
+    // let operation = {
+    //   filterMainIdA: runningFilterMainId,
+    //   operator: lastLogicalOperator,
+    //   filterMainIdB: currentFilterMainId,
+    // };
 
-    return [operationFilterMainId, operationFilterObject, operation, errorsFound, filterElements];
+    return [operationFilterMainId, operationFilterObject, errorsFound, filterElements];
 
   } catch (err) {
     throw (err)
@@ -688,560 +532,422 @@ function filterLogicalElements(
   objType,
   initialLogicalElementId,
   logicalElements,
-  values,
-  // filterElements = {},
-  nextLogicalElementId = null,
-  runningFilterMainId = null,
-  runningFilterObject = null,
-  lastLogicalOperator = null,
-  currentFilterMainId = null,
-  currentFilterObject = null
+  valueUserTags,
 ) {
   console.log('filterLogicalElements: ', {
     objType,
     initialLogicalElementId,
     logicalElements,
-    values,
-    nextLogicalElementId,
-    runningFilterMainId,
-    runningFilterObject,
-    lastLogicalOperator,
-    currentFilterMainId,
-    currentFilterObject
+    valueUserTags,
   });
 
   let errorsObject = {};
   let errorsFound = [];
 
-  let operation = null;
-  let operationErrorsFound = [];
-  let lastNextLogicalElementId = null;
-  let currentLogicalElementId = initialLogicalElementId;
+  let runningFilterObject = null;
+  let runningFilterMainId = null;
+  let currentFilterObject = null;
+  let currentFilterMainId = null;
 
+  let lastLogicalOperator = null;
   let filterElements = {};
 
-  if (nextLogicalElementId !== null) {
-    currentLogicalElementId = nextLogicalElementId;
-  }
+  let nextElementId = null;
 
-  let logicalElement = logicalElements[currentLogicalElementId];
-  console.log('logicalElement: ', logicalElement)
+  let working_logicalElementId = initialLogicalElementId;
+  console.log("working_logicalElementId: ", working_logicalElementId)
 
-  if (isEmpty(logicalElement)) {
-    errorsObject[currentLogicalElementId] = 'this logicalElement not found';
-    errorsFound.push(`${currentLogicalElementId}: this logicalElement not found`);
-  };
-  if (!logicalElement.hasOwnProperty('logicalElementType')) {
-    errorsObject[currentLogicalElementId] = 'this logicalElement is not set logicalElementType';
-    errorsFound.push(`${currentLogicalElementId}: this logicalElement  not set logicalElementType`);
-  };
+  for (let i = 0; i <= MAX_LOGICALS; i++) {
 
-  let logicalElementType = logicalElement.logicalElementType;
-  console.log('logicalElementType: ', logicalElementType);
+    if (i === MAX_LOGICALS) {
 
-  if (logicalElementType === "operation") {
+      if (i < Object.keys(logicalElements).length) {
+        errorsObject = {
+          [initialLogicalElementId]: 'has remain logicalElements that want to process'
+        };
+        errorsFound.push(`${initialLogicalElementId}: has remain logicalElements that want to process`)
+      }
 
-    lastLogicalOperator = logicalElement.operation;
+      errorsObject = {
+        [initialLogicalElementId]: 'has max limit iterate in logicalElements'
+      };
+      errorsFound.push(`${initialLogicalElementId}: has max limit iterate in logicalElements`);
 
-    if (logicalElement.nextLogicalElementId === null) {
-      errorsObject[initialLogicalElementId] = `this operation structure must set nextLogicalElementId`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} must set nextLogicalElementId`);
+      return [null, null, errorsObject, errorsFound, null];
     }
 
-    logicalElement = logicalElements[logicalElement.nextLogicalElementId];
-    logicalElementType = logicalElement.logicalElementType;
+    console.log("iterate logicalElements: ", {
+      runningFilterMainId,
+      runningFilterObject,
+      currentFilterMainId,
+      currentFilterObject,
+      lastLogicalOperator,
+      filterElements
+    })
 
-  }
+    let logicalElement = logicalElements[working_logicalElementId];
+    console.log("logicalElement: ", logicalElement);
 
-  if (logicalElementType === "openBracket") {
+    if (isEmpty(logicalElement)) {
+      errorsObject[currentLogicalElementId] = 'this logicalElement not found';
+      errorsFound.push(`${currentLogicalElementId}: this logicalElement not found`);
+    };
+    if (!logicalElement.hasOwnProperty('logicalElementType')) {
+      errorsObject[currentLogicalElementId] = 'this logicalElement is not set logicalElementType';
+      errorsFound.push(`${currentLogicalElementId}: this logicalElement  not set logicalElementType`);
+    };
 
-    let nextElementId = null;
-    let returnFilterElements = {};
+    let logicalElementType = logicalElement.logicalElementType;
+    console.log('logicalElementType: ', logicalElementType);
 
-    [
-      currentFilterMainId,
-      currentFilterObject,
-      operation,
-      errorsObject,
-      errorsFound,
-      nextElementId,
-      returnFilterElements
-    ] = filterLogicalElements(
-      objType,
-      initialLogicalElementId,
-      logicalElements,
-      values,
-      // filterElements,
-      logicalElement.nextLogicalElementId
-    );
-    console.log('return filterLogicalElement for openBracket: ', {
-      currentFilterMainId,
-      currentFilterObject,
-      operation,
-      errorsObject, errorsFound,
-      lastNextLogicalElementId,
-      returnFilterElements
-    });
+    if (logicalElementType === "operation") {
+
+      if (!logicalElement.hasOwnProperty("operation")) {
+        errorsObject[working_logicalElementId] = `this logical structure is not set operation`;
+        errorsFound.push(`this logical structure logicalElementId: ${working_logicalElementId} is not set operation`);
+      };
 
-    console.log("bb", bb)
+      if (errorsFound.length > 0) {
+        return [null, null, null, errorsObject, errorsFound];
+      }
 
-    if (nextElementId !== null) {
-      lastNextLogicalElementId = nextElementId;
+      lastLogicalOperator = logicalElement.operation;
+      working_logicalElementId = logicalElement.nextLogicalElementId;
+      continue;
     }
 
-  } else if (logicalElementType === "closeBracket") {
+    if (logicalElementType === "openBracket") {
 
-    return [
-      runningFilterMainId,
-      runningFilterObject,
-      null,
-      errorsObject,
-      errorsFound,
-      logicalElement.nextLogicalElementId
-    ]
+      let returnFilterElements = {};
+      let logicalErrorsObject = {};
+      let logicalErrorsFound = [];
 
-  }
+      [currentFilterMainId, currentFilterObject, logicalErrorsObject, logicalErrorsFound, returnFilterElements, nextElementId] = filterLogicalElements(
+        objType,
+        logicalElement.nextLogicalElementId,
+        logicalElements,
+        valueUserTags
+      );
+      console.log('return filter of openBracket: ', {
+        currentFilterMainId,
+        currentFilterObject,
+        logicalErrorsObject,
+        logicalErrorsFound,
+        returnFilterElements,
+        nextElementId
+      });
 
-  console.log("check logicalElement: ", logicalElement);
-  console.log("check logicalElementType: ", logicalElementType);
-  console.log("check filter main id: ", {
-    runningFilterMainId,
-    lastLogicalOperator,
-    currentFilterMainId
-  });
+      if (logicalErrorsFound.length > 0) {
+        Object.assign(errorsObject, logicalErrorsObject);
+        errorsFound = errorsFound.concat(logicalErrorsFound);
+      };
 
-  console.log("check filter main id: ", {
-    runningFilterMainId,
-    runningFilterObject,
-    lastLogicalOperator,
-    currentFilterMainId,
-    currentFilterObject
-  });
+      Object.assign(filterElements, returnFilterElements);
 
-  if (logicalElementType === "logical") {
+    } else if (logicalElementType === "closeBracket") {
 
-    console.log('------------------ logicalElementType: logical ----------------');
+      return [runningFilterMainId, runningFilterObject, errorsObject, errorsFound, filterElements, logicalElement.nextLogicalElementId];
 
-    if (!logicalElement.hasOwnProperty('objType')) {
-      errorsObject[initialLogicalElementId] = `this logical structure is not set objType`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set objType`);
-    };
-    if (hash(objType) !== hash(logicalElement.objType)) {
-      errorsObject[currentLogicalElementId] = `it' s not the same level objType to process this logicalElement`;
-      errorsFound.push(`it' s not the same level objType to process this logicalElement: ${currentLogicalElementId}`);
-    };
-    if (!logicalElement.hasOwnProperty('fieldName')) {
-      errorsObject[currentLogicalElementId] = `this logical structure is not set fieldName`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set fieldName`);
-    };
-    if (!logicalElement.hasOwnProperty('comparison')) {
-      errorsObject[currentLogicalElementId] = `this logical structure is not set comparison`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set comparison`);
-    };
-    if (!logicalElement.hasOwnProperty('value')) {
-      errorsObject[currentLogicalElementId] = `this logical structure is not set value`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set value`);
     }
 
-    let value = values[logicalElement.value];
-    console.log('value: ', value);
+    if (logicalElementType === "logical") {
 
-    if (isEmpty(value)) {
-      errorsObject[currentLogicalElementId] = `value is empty`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} value is empty`);
-    } else {
-      if (value.hasOwnProperty('valueSource')) {
+      console.log('------------------ logicalElementType: logical ----------------');
 
-        if (value.valueSource !== 'perParentIdentifier') {
-          errorsObject[currentLogicalElementId] = `valueType is not set type: perParentIdentifier`;
-          errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} has valueType is not set type: perParentIdentifier`);
-        };
+      if (!logicalElement.hasOwnProperty('objType')) {
+        errorsObject[initialLogicalElementId] = `this logical structure is not set objType`;
+        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set objType`);
+      };
+      if (hash(objType) !== hash(logicalElement.objType)) {
+        errorsObject[currentLogicalElementId] = `it' s not the same level objType to process this logicalElement`;
+        errorsFound.push(`it' s not the same level objType to process this logicalElement: ${currentLogicalElementId}`);
+      };
+      if (!logicalElement.hasOwnProperty('fieldName')) {
+        errorsObject[currentLogicalElementId] = `this logical structure is not set fieldName`;
+        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set fieldName`);
+      };
+      if (!logicalElement.hasOwnProperty('comparison')) {
+        errorsObject[currentLogicalElementId] = `this logical structure is not set comparison`;
+        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set comparison`);
+      };
+      if (!logicalElement.hasOwnProperty('valueUserTag')) {
+        errorsObject[currentLogicalElementId] = `this logical structure is not set valueUserTags`;
+        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set valueUserTags`);
+      }
 
-        //* create complexFilter normalize here
-        currentFilterObject = {
-          objType: logicalElement.objType,
-          filterElement: {
-            filterType: logicalElementType,
-            fieldName: logicalElement.fieldName,
-            comparison: logicalElement.comparison,
-            valueType: value.valueSource,
-            perParentIdentifierFieldname: value.perParentIdentifierFieldname
-          }
-        };
+      let value = valueUserTags[logicalElement.valueUserTag];
+      console.log('value: ', value);
 
+      if (isEmpty(value)) {
+        errorsObject[currentLogicalElementId] = `value is empty`;
+        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} value is empty`);
       } else {
-
-        //* create complexFilter normalize here
-        currentFilterObject = {
-          objType: logicalElement.objType,
-          filterElement: {
-            filterType: logicalElement.logicalElementType,
-            fieldName: logicalElement.fieldName,
-            comparison: logicalElement.comparison,
-            value: values[logicalElement.value].value
-          }
+        if (value.hasOwnProperty('valueSource')) {
+
+          if (value.valueSource !== 'perParentIdentifier') {
+            errorsObject[currentLogicalElementId] = `valueType is not set type: perParentIdentifier`;
+            errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} has valueType is not set type: perParentIdentifier`);
+          };
+
+          //* create complexFilter normalize here
+          currentFilterObject = {
+            objType: logicalElement.objType,
+            filterElement: {
+              filterType: logicalElementType,
+              fieldName: logicalElement.fieldName,
+              comparison: logicalElement.comparison,
+              valueType: value.valueSource,
+              perParentIdentifierFieldname: value.perParentIdentifierFieldname
+            }
+          };
+
+        } else {
+
+          //* create complexFilter normalize here
+          currentFilterObject = {
+            objType: logicalElement.objType,
+            filterElement: {
+              filterType: logicalElement.logicalElementType,
+              fieldName: logicalElement.fieldName,
+              comparison: logicalElement.comparison,
+              value: valueUserTags[logicalElement.valueUserTag].value
+            }
+          };
         };
       };
-    };
-    console.log('currentFilterObject: ', currentFilterObject);
+      console.log('currentFilterObject: ', currentFilterObject);
 
-    currentFilterMainId = hash(currentFilterObject);
-    console.log('currentFilterMainId: ', currentFilterMainId);
-
-    if (logicalElement.nextLogicalElementId !== null) {
-      lastNextLogicalElementId = logicalElement.nextLogicalElementId;
-    }
+      currentFilterMainId = hash(currentFilterObject);
+      console.log('currentFilterMainId: ', currentFilterMainId);
 
-  } else if (logicalElementType === "childComplexFilter") {
-    console.log('------------------ logicalElementType: childComplexFilter ----------------');
+    } else if (logicalElementType === "childComplexFilter") {
+      console.log('------------------ logicalElementType: childComplexFilter ----------------');
 
-    if (!logicalElement.hasOwnProperty('objType')) {
-      errorsObject[currentLogicalElementId] = `this logical structure is not set objType`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set objType`);
-    };
-    if (hash(objType) !== hash(logicalElement.objType)) {
-      errorsObject[currentLogicalElementId] = `it' s not the same level objType to process this logicalElement`
-      errorsFound.push(`it' s not the same level objType to process this logicalElement: ${currentLogicalElementId}`)
-    };
-
-    if (!logicalElement.hasOwnProperty('pathLinkType')) {
-      errorsObject[currentLogicalElementId] = `this logical structure is not set pathLinkType`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set pathLinkType`);
-    } else {
-      if (!logicalElement.pathLinkType.hasOwnProperty('objType')
-        || !logicalElement.pathLinkType.hasOwnProperty('relType')
-        || !logicalElement.pathLinkType.hasOwnProperty('direction')
-      ) {
-        errorsObject[currentLogicalElementId] = `this logical structure is not set properties in pathLinkType`;
-        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set {objType | relType | direction} in pathLinkType`);
+      if (!logicalElement.hasOwnProperty('objType')) {
+        errorsObject[currentLogicalElementId] = `this logical structure is not set objType`;
+        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set objType`);
+      };
+      if (hash(objType) !== hash(logicalElement.objType)) {
+        errorsObject[currentLogicalElementId] = `it' s not the same level objType to process this logicalElement`
+        errorsFound.push(`it' s not the same level objType to process this logicalElement: ${currentLogicalElementId}`)
       };
-    };
-
-    let childLogicalElementId = logicalElement.childLogicalElementId;
 
-    if (childLogicalElementId === null) {
-      errorsObject[currentLogicalElementId] = `this logicalType: childComplexFilter is not set childLogicalElementId`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} logicalType: childComplexFilter is not set childLogicalElementId`);
-    }
+      if (!logicalElement.hasOwnProperty('pathLinkType')) {
+        errorsObject[currentLogicalElementId] = `this logical structure is not set pathLinkType`;
+        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set pathLinkType`);
+      } else {
+        if (!logicalElement.pathLinkType.hasOwnProperty('objType')
+          || !logicalElement.pathLinkType.hasOwnProperty('relType')
+          || !logicalElement.pathLinkType.hasOwnProperty('direction')
+        ) {
+          errorsObject[currentLogicalElementId] = `this logical structure is not set properties in pathLinkType`;
+          errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} is not set {objType | relType | direction} in pathLinkType`);
+        };
+      };
 
-    if (errorsFound.length > 0) {
-      return [null, null, null, errorsObject, errorsFound];
-    };
+      let childLogicalElementId = logicalElement.childLogicalElementId;
 
-    let [
-      childFilterMainId,
-      childFilterObject,
-      operation,
-      childErrorsObject,
-      childErrorsFound,
-      childNextLogicalElementId,
-      returnFilterElements
-    ] = filterLogicalElements(
-      logicalElement.pathLinkType.objType,
-      initialLogicalElementId,
-      logicalElements,
-      values,
-      // filterElements,
-      logicalElement.childLogicalElementId
-    );
-    console.log('return child filterLogicalElement for child complexFilter: ', {
-      childFilterMainId,
-      childFilterObject,
-      operation,
-      childErrorsObject,
-      childErrorsFound,
-      childNextLogicalElementId,
-      returnFilterElements
-    });
-    if (childErrorsFound.length > 0) {
-      Object.assign(errorsObject, childErrorsObject);
-      errorsFound = errorsFound.concat(childErrorsFound)
-    }
+      if (childLogicalElementId === null) {
+        errorsObject[currentLogicalElementId] = `this logicalType: childComplexFilter is not set childLogicalElementId`;
+        errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} logicalType: childComplexFilter is not set childLogicalElementId`);
+      }
 
-    delete childFilterObject.filterElement.filterElements;
+      if (errorsFound.length > 0) {
+        return [null, null, null, errorsObject, errorsFound];
+      };
 
-    if (isEmpty(returnFilterElements)) {
-      returnFilterElements = { [childFilterMainId]: childFilterObject };
-    } else {
-      returnFilterElements[childFilterMainId] = childFilterObject;
-    }
+      let [childFilterMainId, childFilterObject, childErrorsObject, childErrorsFound, childFilterElements] = filterLogicalElements(
+        logicalElement.pathLinkType.objType,
+        childLogicalElementId,
+        logicalElements,
+        valueUserTags
+      );
+      console.log('return filter main of child complexFilter: ', {
+        childFilterMainId,
+        childFilterObject,
+        childErrorsObject,
+        childErrorsFound,
+        childFilterElements
+      });
 
+      if (childErrorsFound.length > 0) {
+        Object.assign(errorsObject, childErrorsObject);
+        errorsFound = errorsFound.concat(childErrorsFound);
+      };
 
-    // let childFilterElements = splitFilterElements(
-    //   childFilterMainId,
-    //   childFilterObject
-    // );
-    // console.log('childFilterElements: ', childFilterElements);
+      let setRequestProperties = {};
 
-    Object.assign(filterElements, returnFilterElements);
-    let setRequestProperties = {};
+      if (!isEmpty(logicalElement.requestProperties)) {
+        console.log('logicalElement: ', logicalElement);
 
-    if (!isEmpty(logicalElement.requestProperties)) {
-      console.log('logicalElement: ', logicalElement);
-      console.log("ll", ll)
-      for (const [tag, requestPropertyId] of Object.entries(logicalElement.requestProperties)) {
-        console.log('set requestProperties: ', { tag, requestPropertyId });
+        for (const [tag, requestPropertyId] of Object.entries(logicalElement.requestProperties)) {
+          console.log('set requestProperties: ', { tag, requestPropertyId });
 
-        let requestPropertyObject = values[requestPropertyId];
+          let requestPropertyObject = valueUserTags[requestPropertyId];
 
-        if (requestPropertyObject.hasOwnProperty('valueSource')) {
-          errorsObject[initialLogicalElementId] = `requestProperties in filter logicalStructure set valueSource`;
-          errorsFound.push(`this filter logical structure logicalElementId: ${initialLogicalElementId} set valueSource`);
-          continue;
+          if (requestPropertyObject.hasOwnProperty('valueSource')) {
+            errorsObject[initialLogicalElementId] = `requestProperties in filter logicalStructure set valueSource`;
+            errorsFound.push(`this filter logical structure logicalElementId: ${initialLogicalElementId} set valueSource`);
+            continue;
+          };
+          setRequestProperties[tag] = requestPropertyObject.value;
         };
-
-        setRequestProperties[tag] = requestPropertyObject.value;
-
       };
-    };
 
-    currentFilterObject = {
-      objType: logicalElement.objType,
-      filterElement: {
-        filterType: logicalElementType,
-        filterElements: returnFilterElements,
-        childFilterElementId: childFilterMainId,
-        pathLinkType: logicalElement.pathLinkType,
-        requestProperties: setRequestProperties ?? {}
-      }
-    };
-    console.log('currentFilterObject: ', currentFilterObject)
 
-    currentFilterMainId = hash(currentFilterObject);
-    console.log('currentFilterMainId: ', currentFilterMainId);
-
-    if (logicalElement.nextLogicalElementId !== null) {
-      lastNextLogicalElementId = logicalElement.nextLogicalElementId;
-    }
+      currentFilterObject = {
+        objType: logicalElement.objType,
+        filterElement: {
+          filterType: logicalElementType,
+          filterElements: childFilterElements,
+          childFilterElementId: childFilterMainId,
+          pathLinkType: logicalElement.pathLinkType,
+          requestProperties: setRequestProperties ?? {}
+        }
+      };
+      console.log("currentFilterObject: ", currentFilterObject);
 
-  } else if (logicalElementType === "traversal") {
+      currentFilterMainId = hash(currentFilterObject);
+      console.log("currentFilterMainId: ", currentFilterMainId);
 
-    console.log('logicalElementType: ', f);
-  } else if (logicalElementType === "translateIds") {
+      Object.assign(filterElements, childFilterElements);
+      console.log("filterElements: ", filterElements);
 
-    console.log('logicalElementType: ', g);
-  } else if (logicalElementType === "identifiers") {
+    } else if (logicalElementType === "traversal") {
 
-    console.log('logicalElementType: ', h);
-  }
+      console.log('logicalElementType: ', f);
+    } else if (logicalElementType === "translateIds") {
 
-  if (errorsFound.length > 0) {
-    return [null, null, null, errorsObject, errorsFound, null];
-  }
+      console.log('logicalElementType: ', g);
+    } else if (logicalElementType === "identifiers") {
 
-  if (lastNextLogicalElementId !== null) {
+      console.log('logicalElementType: ', h);
+    }
 
-    let validateFilterElements = {};
+    let returnFilterElements = {};
+    let operationErrorsFound = [];
 
-    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound, validateFilterElements] = validateOperation(
+    [runningFilterMainId, runningFilterObject, operationErrorsFound, returnFilterElements] = validateOperation(
       objType,
       runningFilterMainId,
       runningFilterObject,
       lastLogicalOperator,
       currentFilterMainId,
-      currentFilterObject
+      currentFilterObject,
+      filterElements
     );
-    console.log('return validateOperation for lastNextLogicalElementId !== null: ', {
+    console.log('return validate operation : ', {
       runningFilterMainId,
       runningFilterObject,
-      operation,
       operationErrorsFound,
-      validateFilterElements
-    });
-
-    if (currentFilterObject.objType.objectType === "productStandard") {
-      console.log("ff", currentFilterObject.filterElement.filterElements)
-      console.log("ff", ff)
-    }
-
-    if (!isEmpty(operation)) {
-      lastLogicalOperator = null;
-    }
-
-    let [
-      nextFilterMainId,
-      nextFilterObject,
-      operations,
-      nextErrorObject,
-      nextErrorFound,
-      nextElementId,
-      returnFilterElements
-    ] = filterLogicalElements(
-      objType,
-      initialLogicalElementId,
-      logicalElements,
-      values,
-      // filterElements,
-      lastNextLogicalElementId,
-      runningFilterMainId,
-      runningFilterObject,
-      lastLogicalOperator,
-    );
-    console.log('return validateOperation for lastNextLogicalElementId !== null ___1: ', {
-      nextFilterMainId,
-      nextFilterObject,
-      operations,
-      nextErrorObject,
-      nextErrorFound,
-      nextElementId,
       returnFilterElements
     });
 
-    if (nextErrorFound.length > 0) {
-      Object.assign(errorsObject, nextErrorObject);
-      errorsFound = errorsFound.concat(nextErrorFound);
-    }
-
-    Object.assign(filterElements, validateFilterElements, returnFilterElements);
-
-    if (nextElementId !== null) {
+    if (operationErrorsFound.length > 0) {
+      Object.assign(errorsObject, { [initialLogicalElementId]: 'has error in operation' });
+      errorsFound = errorsFound.concat(operationErrorsFound);
+    };
 
-      let filterErrorObject = {};
-      let filterErrorFound = [];
+    if (errorsFound.length > 0) {
+      return [null, null, null, errorsObject, errorsFound];
+    };
 
-      [
-        runningFilterMainId,
-        runningFilterObject,
-        operation,
-        filterErrorObject,
-        filterErrorFound,
-        nextElementId,
-      ] = filterLogicalElements(
-        objType,
-        initialLogicalElementId,
-        logicalElements,
-        values,
-        // filterElements,
-        nextElementId,
-        nextFilterMainId,
-        nextFilterObject,
-        lastLogicalOperator
-      );
-      console.log('return validateOperation for lastNextLogicalElementId !== null ___2: ', {
-        runningFilterMainId,
-        runningFilterObject,
-        operation,
-        filterErrorObject,
-        filterErrorFound,
-        nextElementId
-      });
-      return [
-        runningFilterMainId,
-        runningFilterObject,
-        operation,
-        filterErrorObject,
-        filterErrorFound,
-        nextElementId
-      ];
-    } else {
+    Object.assign(filterElements, returnFilterElements, { [runningFilterMainId]: runningFilterObject });
 
-      return [
-        nextFilterMainId,
-        nextFilterObject,
-        operation,
-        errorsObject,
-        errorsFound,
-        nextElementId,
-        filterElements
-      ];
-    }
+    if (logicalElement.logicalElementType === "openBracket") {
 
-  } else {
-    let returnFilterElements = {};
+      if (nextElementId !== null) {
+        working_logicalElementId = nextElementId;
+      } else {
+        break;
+      }
 
-    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound, returnFilterElements] = validateOperation(
-      objType,
-      runningFilterMainId,
-      runningFilterObject,
-      lastLogicalOperator,
-      currentFilterMainId,
-      currentFilterObject
-    );
-    console.log('return validateOperation for lastNextLogicalElementId == null: ', {
-      runningFilterMainId,
-      runningFilterObject,
-      operation,
-      operationErrorsFound,
-      returnFilterElements
-    });
+    } else {
 
-    if (operationErrorsFound.length > 0) {
-      errorsFound = errorsFound.concat(operationErrorsFound)
+      if (logicalElement.nextLogicalElementId === null) {
+        break;
+      };
+      working_logicalElementId = logicalElement.nextLogicalElementId;
     }
 
-    return [runningFilterMainId, runningFilterObject, operation, errorsObject, errorsFound, null, returnFilterElements];
-
   }
 
-};
-
-function splitFilterElements(
-  runningFilterMainId,
-  runningFilterObject,
-  currentFilterMainId = null,
-  currentFilterObject = null
-) {
-  console.log('split FilterElements: ', {
+  console.log("before return filterLogicalStructure id process: ", {
     runningFilterMainId,
     runningFilterObject,
-    currentFilterMainId,
-    currentFilterObject
+    errorsObject,
+    errorsFound,
+    filterElements
   });
 
-  let filterElements = {};
+  return [runningFilterMainId, runningFilterObject, errorsObject, errorsFound, filterElements, nextElementId];
+
+};
 
-  // if (runningFilterObject.filterElement.filterType === 'logical'
-  //   || runningFilterObject.filterElement.filterType === 'identifiers'
-  //   || runningFilterObject.filterElement.filterType === 'translateIds'
-  //   || runningFilterObject.filterElement.filterType === 'traversal'
-  // ) {}
+// function splitFilterElements(
+//   runningFilterMainId,
+//   runningFilterObject,
+//   currentFilterMainId = null,
+//   currentFilterObject = null
+// ) {
+//   console.log('split FilterElements: ', {
+//     runningFilterMainId,
+//     runningFilterObject,
+//     currentFilterMainId,
+//     currentFilterObject
+//   });
 
-  if (runningFilterObject.filterElement.filterType === 'operation') {
-    console.log('-------- operation ----------');
+//   let filterElements = {};
 
-    Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
-    // delete runningFilterObject.filterElement.filterElements;
-    filterElements[runningFilterMainId] = runningFilterObject;
+//   // if (runningFilterObject.filterElement.filterType === 'logical'
+//   //   || runningFilterObject.filterElement.filterType === 'identifiers'
+//   //   || runningFilterObject.filterElement.filterType === 'translateIds'
+//   //   || runningFilterObject.filterElement.filterType === 'traversal'
+//   // ) {}
 
-  } else if (runningFilterObject.filterElement.filterType === 'childComplexFilter') {
-    console.log('-------- childComplexFilter ----------');
+//   if (runningFilterObject.filterElement.filterType === 'operation') {
+//     console.log('-------- operation ----------');
 
-    Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
-    // delete runningFilterObject.filterElement.filterElements;
-    filterElements[runningFilterMainId] = runningFilterObject;
+//     Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
+//     // delete runningFilterObject.filterElement.filterElements;
+//     filterElements[runningFilterMainId] = runningFilterObject;
 
-  } else {
-    console.log(` -------- ${runningFilterObject.filterElement.filterType} ----------`);
-    //'logical'| 'identifiers'|'translateIds'|'traversal'
-    filterElements[runningFilterMainId] = runningFilterObject;
-  };
+//   } else if (runningFilterObject.filterElement.filterType === 'childComplexFilter') {
+//     console.log('-------- childComplexFilter ----------');
 
-  if (currentFilterObject !== null) {
-    if (currentFilterObject.filterType === 'operation') {
-      console.log('-------- operation ----------');
+//     Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
+//     // delete runningFilterObject.filterElement.filterElements;
+//     filterElements[runningFilterMainId] = runningFilterObject;
 
-      Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
-      // delete currentFilterObject.filterElement.filterElements;
-      filterElements[currentFilterMainId] = currentFilterObject;
+//   } else {
+//     console.log(` -------- ${runningFilterObject.filterElement.filterType} ----------`);
+//     //'logical'| 'identifiers'|'translateIds'|'traversal'
+//     filterElements[runningFilterMainId] = runningFilterObject;
+//   };
 
-    } else if (currentFilterObject.filterElement.filterType === 'childComplexFilter') {
-      console.log('-------- childComplexFilter ----------');
+//   if (currentFilterObject !== null) {
+//     if (currentFilterObject.filterType === 'operation') {
+//       console.log('-------- operation ----------');
 
-      Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
-      delete currentFilterObject.filterElement.filterElements;
-      filterElements[currentFilterMainId] = currentFilterObject;
+//       Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
+//       // delete currentFilterObject.filterElement.filterElements;
+//       filterElements[currentFilterMainId] = currentFilterObject;
 
-    } else {
-      console.log(` -------- ${currentFilterObject.filterElement.filterType} ----------`);
-      //'logical'| 'identifiers'|'translateIds'|'traversal'
-      filterElements[currentFilterMainId] = currentFilterObject;
-    };
-  };
+//     } else if (currentFilterObject.filterElement.filterType === 'childComplexFilter') {
+//       console.log('-------- childComplexFilter ----------');
 
-  return filterElements;
+//       Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
+//       delete currentFilterObject.filterElement.filterElements;
+//       filterElements[currentFilterMainId] = currentFilterObject;
 
-};
+//     } else {
+//       console.log(` -------- ${currentFilterObject.filterElement.filterType} ----------`);
+//       //'logical'| 'identifiers'|'translateIds'|'traversal'
+//       filterElements[currentFilterMainId] = currentFilterObject;
+//     };
+//   };
 
+//   return filterElements;}
 
 export default {
   //* create filter