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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-shared-search-and-sort",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Shared Libraries frontend/backend for Search and Sort stack",
   "main": "index.js",
   "scripts": {

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,
@@ -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,
+      {
+        objType: objType,
+        initialLogicalElementId: initialLogicalElementId,
+        logicalElements: logicalElements
+      },
+      [],
       errorsObject,
       errorsFound
     );
@@ -133,15 +140,6 @@ 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);
@@ -154,6 +152,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 +190,12 @@ async function createRequiredData(
       console.log("------- requiredData has only fieldName ---------");
 
       let requiredFieldNameObject = {
-        fieldName: fieldName
+        fieldName: {
+          fieldName: fieldName
+        },
+        //* don hash
+        linkPathObjects: {},
+        linkPathSteps: {}
       };
       console.log("requiredFieldNameObject: ", requiredFieldNameObject);
 
@@ -268,6 +280,7 @@ async function createRequiredData(
 
 
 async function createLinkPath(
+  objType,
   linkSteps,
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
@@ -339,12 +352,13 @@ async function createLinkPath(
     }
 
     let conditionsPromise = checkConditionsLink(
-      // let [conditions, conditionErrObject, conditionErrFound] = await this.checkConditionsLink(
+      // let [conditions, conditionErrObject, conditionErrFound] = await checkConditionsLink(
       linkStep.pathLinkType.objType,
       linkStep,
       perParentCombinations,
       complexFilterCombinations,
       values,
+      filtersStructure,
       linkSteps,
       requiredDataLinkStepObjects,
       requiredDataLinkSteps,
@@ -352,8 +366,14 @@ 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,
@@ -629,7 +649,7 @@ async function createLinkPath(
       console.log('returnValue', returnValue);
     }
   }
-  return [fieldName, returnValue, errorsObject, errorsFound]
+  return [fieldName, returnValue, errorsObject, errorsFound, sortObj]
 }
 
 
@@ -798,13 +818,17 @@ 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,
@@ -820,7 +844,8 @@ async function checkConditionsLink(
         fieldName,
         childLinkStep,
         linkErrorsObject,
-        linkErrorsFound
+        linkErrorsFound,
+        sortObj
       });
 
       if (linkErrorsFound > 0) {

package/src/FiltersSharedLib.js

@@ -19,6 +19,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
+import objectHash from 'object-hash';
 const { isEmpty } = lodash;
 
 function validateFilterElement(
@@ -75,58 +76,65 @@ function createFiltersRequest(
   let filterMainId = null;
   let filterMainObject = {};
   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
-    ];
-  };
+  // //* 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 = {};
 
   [
     filterMainId,
     filterMainObject,
     operation,
     operationErrorsObject,
-    operationErrors
+    operationErrors,
+    nextFilterElementId,
+    returnFilterElements
   ] = filterLogicalElements(
     objType,
     initialLogicalElementId,
     logicalElements,
     values,
   );
+
   console.log('final return filterLogicalElements: ', {
     filterMainId,
     filterMainObject,
     operation,
     operationErrorsObject,
-    operationErrors
+    operationErrors,
+    nextFilterElementId,
+    returnFilterElements
   });
 
   if (errorsFound.length > 0 || filterMainId === null) {
@@ -141,10 +149,9 @@ function createFiltersRequest(
   };
 
   let filterElements = {};
-  if (filterMainObject.filterElement.hasOwnProperty('filterElements')) {
-    filterElements = filterMainObject.filterElement.filterElements;
-
-    delete filterMainObject.filterElement.filterElements;
+  // if (filterMainObject.filterElement.hasOwnProperty('filterElements') || isEmpty(returnFilterElements)) {
+  if (!isEmpty(returnFilterElements)) {
+    filterElements = returnFilterElements;
     Object.assign(filterElements, { [filterMainId]: filterMainObject });
   };
 
@@ -260,7 +267,9 @@ function validateCombinationStructure(
         initialLogicalElementId = nextElementId;
       };
 
-    } else if (logicalElementType === 'closeBracket') {
+    }
+
+    if (logicalElementType === 'closeBracket') {
       console.log('----------------- closeBracket --------------');
 
       return [
@@ -627,7 +636,9 @@ function validateOperation(
     // 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 ++");
-      return [currentFilterMainId, currentFilterObject, null, errorsFound];
+      let filterElements = currentFilterObject.filterElement.filterElements;
+      delete currentFilterObject.filterElement.filterElements;
+      return [currentFilterMainId, currentFilterObject, null, errorsFound, filterElements];
     }
 
     let filterElements = splitFilterElements(
@@ -637,6 +648,8 @@ function validateOperation(
       currentFilterObject
     );
 
+    console.log("----------------------------------------------------- filterElements", filterElements);
+
     // create new operation FilterObject
     let operationFilterObject = {
       objType: objType,
@@ -654,6 +667,7 @@ function validateOperation(
     console.log("==== validate operationFilterMainId After Hash =====", operationFilterMainId);
 
     console.log("RETURN validate operationFilterMainId ==>", operationFilterMainId);
+    delete operationFilterObject.filterElement.filterElements;
     console.log("RETURN validate operationFilterObject ==>", operationFilterObject);
     console.log("========= [validateOperation ::: End] =======");
 
@@ -663,7 +677,7 @@ function validateOperation(
       filterMainIdB: currentFilterMainId,
     };
 
-    return [operationFilterMainId, operationFilterObject, operation, errorsFound];
+    return [operationFilterMainId, operationFilterObject, operation, errorsFound, filterElements];
 
   } catch (err) {
     throw (err)
@@ -675,6 +689,7 @@ function filterLogicalElements(
   initialLogicalElementId,
   logicalElements,
   values,
+  // filterElements = {},
   nextLogicalElementId = null,
   runningFilterMainId = null,
   runningFilterObject = null,
@@ -703,6 +718,8 @@ function filterLogicalElements(
   let lastNextLogicalElementId = null;
   let currentLogicalElementId = initialLogicalElementId;
 
+  let filterElements = {};
+
   if (nextLogicalElementId !== null) {
     currentLogicalElementId = nextLogicalElementId;
   }
@@ -722,9 +739,24 @@ function filterLogicalElements(
   let logicalElementType = logicalElement.logicalElementType;
   console.log('logicalElementType: ', logicalElementType);
 
+  if (logicalElementType === "operation") {
+
+    lastLogicalOperator = logicalElement.operation;
+
+    if (logicalElement.nextLogicalElementId === null) {
+      errorsObject[initialLogicalElementId] = `this operation structure must set nextLogicalElementId`;
+      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} must set nextLogicalElementId`);
+    }
+
+    logicalElement = logicalElements[logicalElement.nextLogicalElementId];
+    logicalElementType = logicalElement.logicalElementType;
+
+  }
+
   if (logicalElementType === "openBracket") {
 
     let nextElementId = null;
+    let returnFilterElements = {};
 
     [
       currentFilterMainId,
@@ -732,12 +764,14 @@ function filterLogicalElements(
       operation,
       errorsObject,
       errorsFound,
-      nextElementId
+      nextElementId,
+      returnFilterElements
     ] = filterLogicalElements(
       objType,
       initialLogicalElementId,
       logicalElements,
       values,
+      // filterElements,
       logicalElement.nextLogicalElementId
     );
     console.log('return filterLogicalElement for openBracket: ', {
@@ -745,9 +779,12 @@ function filterLogicalElements(
       currentFilterObject,
       operation,
       errorsObject, errorsFound,
-      lastNextLogicalElementId
+      lastNextLogicalElementId,
+      returnFilterElements
     });
 
+    console.log("bb", bb)
+
     if (nextElementId !== null) {
       lastNextLogicalElementId = nextElementId;
     }
@@ -763,18 +800,6 @@ function filterLogicalElements(
       logicalElement.nextLogicalElementId
     ]
 
-  } else if (logicalElementType === "operation") {
-
-    lastLogicalOperator = logicalElement.operation;
-
-    if (logicalElement.nextLogicalElementId === null) {
-      errorsObject[initialLogicalElementId] = `this operation structure must set nextLogicalElementId`;
-      errorsFound.push(`this logical structure logicalElementId: ${currentLogicalElementId} must set nextLogicalElementId`);
-    }
-
-    logicalElement = logicalElements[logicalElement.nextLogicalElementId];
-    logicalElementType = logicalElement.logicalElementType;
-
   }
 
   console.log("check logicalElement: ", logicalElement);
@@ -909,12 +934,14 @@ function filterLogicalElements(
       operation,
       childErrorsObject,
       childErrorsFound,
-      childNextLogicalElementId
+      childNextLogicalElementId,
+      returnFilterElements
     ] = filterLogicalElements(
       logicalElement.pathLinkType.objType,
       initialLogicalElementId,
       logicalElements,
       values,
+      // filterElements,
       logicalElement.childLogicalElementId
     );
     console.log('return child filterLogicalElement for child complexFilter: ', {
@@ -923,23 +950,35 @@ function filterLogicalElements(
       operation,
       childErrorsObject,
       childErrorsFound,
-      childNextLogicalElementId
+      childNextLogicalElementId,
+      returnFilterElements
     });
     if (childErrorsFound.length > 0) {
       Object.assign(errorsObject, childErrorsObject);
       errorsFound = errorsFound.concat(childErrorsFound)
     }
 
-    let filterElements = splitFilterElements(
-      childFilterMainId,
-      childFilterObject
-    );
-    console.log('filterElements: ', filterElements);
+    delete childFilterObject.filterElement.filterElements;
+
+    if (isEmpty(returnFilterElements)) {
+      returnFilterElements = { [childFilterMainId]: childFilterObject };
+    } else {
+      returnFilterElements[childFilterMainId] = childFilterObject;
+    }
+
+
+    // let childFilterElements = splitFilterElements(
+    //   childFilterMainId,
+    //   childFilterObject
+    // );
+    // console.log('childFilterElements: ', childFilterElements);
+
+    Object.assign(filterElements, returnFilterElements);
     let setRequestProperties = {};
 
     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 });
 
@@ -960,13 +999,13 @@ function filterLogicalElements(
       objType: logicalElement.objType,
       filterElement: {
         filterType: logicalElementType,
-        filterElements: filterElements,
+        filterElements: returnFilterElements,
         childFilterElementId: childFilterMainId,
         pathLinkType: logicalElement.pathLinkType,
         requestProperties: setRequestProperties ?? {}
       }
     };
-    console.log('currentFilterObject: ', currentFilterObject);
+    console.log('currentFilterObject: ', currentFilterObject)
 
     currentFilterMainId = hash(currentFilterObject);
     console.log('currentFilterMainId: ', currentFilterMainId);
@@ -992,7 +1031,9 @@ function filterLogicalElements(
 
   if (lastNextLogicalElementId !== null) {
 
-    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound] = validateOperation(
+    let validateFilterElements = {};
+
+    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound, validateFilterElements] = validateOperation(
       objType,
       runningFilterMainId,
       runningFilterObject,
@@ -1000,13 +1041,19 @@ function filterLogicalElements(
       currentFilterMainId,
       currentFilterObject
     );
-    console.log('return validateOperation for lastNextLogicalElementId == null: ', {
+    console.log('return validateOperation for lastNextLogicalElementId !== null: ', {
       runningFilterMainId,
       runningFilterObject,
       operation,
-      operationErrorsFound
+      operationErrorsFound,
+      validateFilterElements
     });
 
+    if (currentFilterObject.objType.objectType === "productStandard") {
+      console.log("ff", currentFilterObject.filterElement.filterElements)
+      console.log("ff", ff)
+    }
+
     if (!isEmpty(operation)) {
       lastLogicalOperator = null;
     }
@@ -1017,24 +1064,27 @@ function filterLogicalElements(
       operations,
       nextErrorObject,
       nextErrorFound,
-      nextElementId
+      nextElementId,
+      returnFilterElements
     ] = filterLogicalElements(
       objType,
       initialLogicalElementId,
       logicalElements,
       values,
+      // filterElements,
       lastNextLogicalElementId,
       runningFilterMainId,
       runningFilterObject,
       lastLogicalOperator,
     );
-    console.log('return validateOperation for lastNextLogicalElementId !== null: ', {
+    console.log('return validateOperation for lastNextLogicalElementId !== null ___1: ', {
       nextFilterMainId,
       nextFilterObject,
       operations,
       nextErrorObject,
       nextErrorFound,
-      nextElementId
+      nextElementId,
+      returnFilterElements
     });
 
     if (nextErrorFound.length > 0) {
@@ -1042,7 +1092,10 @@ function filterLogicalElements(
       errorsFound = errorsFound.concat(nextErrorFound);
     }
 
+    Object.assign(filterElements, validateFilterElements, returnFilterElements);
+
     if (nextElementId !== null) {
+
       let filterErrorObject = {};
       let filterErrorFound = [];
 
@@ -1052,18 +1105,19 @@ function filterLogicalElements(
         operation,
         filterErrorObject,
         filterErrorFound,
-        nextElementId
+        nextElementId,
       ] = filterLogicalElements(
         objType,
         initialLogicalElementId,
         logicalElements,
         values,
+        // filterElements,
         nextElementId,
         nextFilterMainId,
         nextFilterObject,
         lastLogicalOperator
       );
-      console.log('return validateOperation for lastNextLogicalElementId !== null: ', {
+      console.log('return validateOperation for lastNextLogicalElementId !== null ___2: ', {
         runningFilterMainId,
         runningFilterObject,
         operation,
@@ -1080,19 +1134,22 @@ function filterLogicalElements(
         nextElementId
       ];
     } else {
+
       return [
         nextFilterMainId,
         nextFilterObject,
         operation,
         errorsObject,
         errorsFound,
-        nextElementId
+        nextElementId,
+        filterElements
       ];
     }
 
   } else {
+    let returnFilterElements = {};
 
-    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound] = validateOperation(
+    [runningFilterMainId, runningFilterObject, operation, operationErrorsFound, returnFilterElements] = validateOperation(
       objType,
       runningFilterMainId,
       runningFilterObject,
@@ -1104,14 +1161,15 @@ function filterLogicalElements(
       runningFilterMainId,
       runningFilterObject,
       operation,
-      operationErrorsFound
+      operationErrorsFound,
+      returnFilterElements
     });
 
     if (operationErrorsFound.length > 0) {
       errorsFound = errorsFound.concat(operationErrorsFound)
     }
 
-    return [runningFilterMainId, runningFilterObject, operation, errorsObject, errorsFound, null];
+    return [runningFilterMainId, runningFilterObject, operation, errorsObject, errorsFound, null, returnFilterElements];
 
   }
 
@@ -1138,14 +1196,14 @@ function splitFilterElements(
   //   || runningFilterObject.filterElement.filterType === 'traversal'
   // ) {}
 
-  if (runningFilterObject.logicalElementType === 'operation') {
+  if (runningFilterObject.filterElement.filterType === 'operation') {
     console.log('-------- operation ----------');
 
     Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
     // delete runningFilterObject.filterElement.filterElements;
     filterElements[runningFilterMainId] = runningFilterObject;
 
-  } else if (runningFilterObject.logicalElementType === 'childComplexFilter') {
+  } else if (runningFilterObject.filterElement.filterType === 'childComplexFilter') {
     console.log('-------- childComplexFilter ----------');
 
     Object.assign(filterElements, runningFilterObject.filterElement.filterElements);
@@ -1153,28 +1211,28 @@ function splitFilterElements(
     filterElements[runningFilterMainId] = runningFilterObject;
 
   } else {
-    console.log(` -------- ${runningFilterObject.logicalElementType} ----------`);
+    console.log(` -------- ${runningFilterObject.filterElement.filterType} ----------`);
     //'logical'| 'identifiers'|'translateIds'|'traversal'
     filterElements[runningFilterMainId] = runningFilterObject;
   };
 
   if (currentFilterObject !== null) {
-    if (currentFilterObject.logicalElementType === 'operation') {
+    if (currentFilterObject.filterType === 'operation') {
       console.log('-------- operation ----------');
 
       Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
       // delete currentFilterObject.filterElement.filterElements;
       filterElements[currentFilterMainId] = currentFilterObject;
 
-    } else if (currentFilterObject.logicalElementType === 'childComplexFilter') {
+    } else if (currentFilterObject.filterElement.filterType === 'childComplexFilter') {
       console.log('-------- childComplexFilter ----------');
 
       Object.assign(filterElements, currentFilterObject.filterElement.filterElements);
-      // delete currentFilterObject.filterElement.filterElements;
+      delete currentFilterObject.filterElement.filterElements;
       filterElements[currentFilterMainId] = currentFilterObject;
 
     } else {
-      console.log(` -------- ${currentFilterObject.logicalElementType} ----------`);
+      console.log(` -------- ${currentFilterObject.filterElement.filterType} ----------`);
       //'logical'| 'identifiers'|'translateIds'|'traversal'
       filterElements[currentFilterMainId] = currentFilterObject;
     };

package/src/LogicalStructureSharedLib.js

@@ -906,9 +906,7 @@ async function changeObjTypePath(
   };
 
 };
-//###################################################################################################################################################################################
-
-
+// ###################################################################################################################################################################################
 
 
 function createChildComplexFilterStructure(

package/src/SearchSortSharedLib.js

@@ -35,7 +35,6 @@ async function createSearchRequest(
   requiredDataLinkStepObjects,
   requiredDataLinkSteps,
   values,
-  getSchemaFn
 ) {
   console.log('createSearchResult: ', {
     objType,
@@ -57,13 +56,14 @@ async function createSearchRequest(
 
   let requiredDataPromise = dataFieldsSharedLib.createRequiredData(
     objType,
+    initialLogicalElementId,
+    logicalElements,
     requiredDataFields,
     complexFilterCombinations,
     perParentCombinations,
     requiredDataLinkStepObjects,
     requiredDataLinkSteps,
     values,
-    getSchemaFn
   );
 
   //* create complexFilter normalize to send backend