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

package/src/LogicalStructureSharedLib.js

@@ -17,13 +17,14 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 'use strict';
 
-
 import { objectHash as hash } from '@izara_project/izara-shared-core';
 import lodash from 'lodash';
 const { isEmpty } = lodash;
 import { v4 as uuidV4 } from 'uuid';
 const MAX_ITER = 4;
 
+const MAX_LOGICALS = 50;
+
 let getObjectSchema = {};
 
 function initSchemaFn(getObjSchemaS3WithHierarchyShared, getObjectLinksShared) {
@@ -34,7 +35,6 @@ function initSchemaFn(getObjSchemaS3WithHierarchyShared, getObjectLinksShared) {
   return getObjectSchema;
 }
 
-
 function combineLogicalStructure(
   objType,
   initialLogicalElementId,
@@ -45,180 +45,136 @@ function combineLogicalStructure(
     initialLogicalElementId,
     logicalElements,
   });
-
-  let returnInitialElementId = null;
-  let initialLogicalElementObject = logicalElements[initialLogicalElementId]
-  if (initialLogicalElementObject.logicalElementType !== 'logicalStructure') {
-    returnInitialElementId = initialLogicalElementId;
-  } else {
-    returnInitialElementId = logicalElements[initialLogicalElementId].initialLogicalElementId;
-  };
-  console.log('returnInitialElementId', returnInitialElementId);
-
-  let previousLogicalElementId = null;
-  let previousLogicalElementObject = null;
-
-  let operationLogicalElementId = null;
-  let operationLogicalElementObject = null;
-
-  let nextLogicalElementId = null;
-  let nextLogicalElementObject = null;
-
-  let returnLogicalElements = {};
-
   let errorsObject = {};
   let errorsFound = [];
 
-  for (const [logicalElementId, logicalElementObject] of Object.entries(logicalElements)) {
-    console.log('extract logicalELements: ', { initialLogicalElementId, logicalElementId, logicalElementObject });
+  let combineFilterStructure = {};
 
-    if (initialLogicalElementId !== logicalElementId) {
-      continue;
-    };
+  let working_logicalElementId = initialLogicalElementId;
 
-    let logicalElementType = logicalElementObject.logicalElementType;
-    console.log('logicalElementType: ', logicalElementType);
+  for (let i = 0; i < MAX_LOGICALS; i++) {
 
-    if (logicalElementType === 'openBracket') {
-      console.log('----------type: openBracket ----------');
-      if (!logicalElementObject.hasOwnProperty('previousLogicalElementId')) {
-        errorsObject[logicalElementId] = `this logical structure is not set previousLogicalElementId`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set previousLogicalElementId`);
-      };
-      if (!logicalElementObject.hasOwnProperty('nextLogicalElementId')) {
-        errorsObject[logicalElementId] = `this logical structure is not set nextLogicalElementId`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set nextLogicalElementId`);
+    if (i === MAX_LOGICALS) {
+
+      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`)
+      }
+
+      errorsObject = {
+        [initialLogicalElementId]: 'has max limit iterate in logicalElements'
       };
+      errorsFound.push(`${initialLogicalElementId}: has max limit iterate in logicalElements`)
+      return [null, errorsObject, errorsFound];
+    }
 
-      nextLogicalElementId = logicalElementId;
-      nextLogicalElementObject = { [nextLogicalElementId]: logicalElementObject };
-      initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+    let logicalElement = logicalElements[working_logicalElementId];
+    console.log("logicalElement: ", logicalElement);
 
-    } else if (logicalElementType === 'logicalStructure') {
-      console.log('----------type: logicalStructure ----------');
+    let lastLogicalElementId = null;
 
-      if (!logicalElementObject.hasOwnProperty('objType')) {
-        errorsObject[logicalElementId] = `this logical structure is not set objType`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set objType`);
-      };
-      if (!logicalElementObject.hasOwnProperty('initialLogicalElementId')) {
-        errorsObject[logicalElementId] = `this logical structure is not set initialLogicalElementId`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set initialLogicalElementId`);
-      };
-      if (!logicalElementObject.hasOwnProperty('previousLogicalElementId')) {
-        errorsObject[logicalElementId] = `this logical structure is not set previousLogicalElementId`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set previousLogicalElementId`);
-      };
-      if (!logicalElementObject.hasOwnProperty('nextLogicalElementId')) {
-        errorsObject[logicalElementId] = `this logical structure is not set nextLogicalElementId`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set nextLogicalElementId`);
-      };
-      if (!logicalElementObject.hasOwnProperty('logicalElements')) {
-        errorsObject[logicalElementId] = `this logical structure is not set logicalElements`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set logicalElements`);
-      };
+    if (!isEmpty(combineFilterStructure)) {
+      lastLogicalElementId = combineFilterStructure.initialLogicalElementId;
+    }
 
-      nextLogicalElementId = logicalElementObject.initialLogicalElementId;
-      nextLogicalElementObject = logicalElementObject.logicalElements;
+    for (let j = 0; j <= MAX_LOGICALS; j++) {
 
-      if (logicalElementObject.nextLogicalElementId !== null) {
-        initialLogicalElementId = logicalElementObject.nextLogicalElementId;
-      };
+      if (j === MAX_LOGICALS) {
+        errorsObject = {
+          [initialLogicalElementId]: 'has max limit iterate in logicalElements'
+        };
+        errorsFound.push(`${initialLogicalElementId}: has max limit iterate in logicalElements`)
+        return [null, errorsObject, errorsFound];
+      }
 
-    } else if (logicalElementType === 'operation') {
-      console.log('----------type: operation ----------');
-      if (!logicalElementObject.hasOwnProperty('previousLogicalElementId')) {
-        errorsObject[logicalElementId] = `this logical structure is not set previousLogicalElementId`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set previousLogicalElementId`);
-      };
-      if (!logicalElementObject.hasOwnProperty('nextLogicalElementId')) {
-        errorsObject[logicalElementId] = `this logical structure is not set nextLogicalElementId`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set nextLogicalElementId`);
-      };
-      if (!logicalElementObject.hasOwnProperty('operation')) {
-        errorsObject[logicalElementId] = `this logical structure is not set operation`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set operation`);
-      };
+      if (!isEmpty(combineFilterStructure)) {
+        let lastLogicalElement = combineFilterStructure.logicalElements[lastLogicalElementId];
+        if (lastLogicalElement.nextLogicalElementId === null) {
+          break;
+        }
+        lastLogicalElementId = lastLogicalElement.nextLogicalElementId;
+      } else {
+        break;
+      }
+    }
+    console.log("lastLogicalElementId: ", lastLogicalElementId);
+
+    if (logicalElement.logicalElementType === "openBracket") {
+
+      if (isEmpty(combineFilterStructure)) {
+        combineFilterStructure.objType = objType;
+        combineFilterStructure.initialLogicalElementId = working_logicalElementId;
+        combineFilterStructure.logicalElements = {
+          [working_logicalElementId]: {
+            logicalElementType: "openBracket",
+            previousLogicalElementId: null,
+            nextLogicalElementId: null,
+          }
+        }
 
-      operationLogicalElementId = logicalElementId;
-      operationLogicalElementObject = logicalElementObject;
-      initialLogicalElementId = logicalElementObject.nextLogicalElementId;
-      continue;
+      } else {
+        combineFilterStructure.logicalElements[lastLogicalElementId].nextLogicalElementId = working_logicalElementId;
+        Object.assign(combineFilterStructure.logicalElements, {
+          [working_logicalElementId]: {
+            logicalElementType: 'openBracket',
+            previousLogicalElementId: lastLogicalElementId,
+            nextLogicalElementId: null
+          }
+        });
+      }
 
-    } else if (logicalElementType === 'closeBracket') {
-      console.log('----------type: closeBracket ----------');
-      if (!logicalElementObject.hasOwnProperty('previousLogicalElementId')) {
-        errorsObject[logicalElementId] = `this logical structure is not set previousLogicalElementId`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set previousLogicalElementId`);
-      };
-      if (!logicalElementObject.hasOwnProperty('nextLogicalElementId')) {
-        errorsObject[logicalElementId] = `this logical structure is not set nextLogicalElementId`;
-        errorsFound.push(`this logical structure logicalElementId: ${logicalElementId} is not set nextLogicalElementId`);
-      };
+      console.log("combineFilterStructure: ", combineFilterStructure);
 
-      nextLogicalElementId = logicalElementId;
-      nextLogicalElementObject = { [nextLogicalElementId]: logicalElementObject };
-      initialLogicalElementId = logicalElementObject.nextLogicalElementId;
+    } else if (logicalElement.logicalElementType === "closeBracket") {
 
-    } else {
-      //* error
-      errorsObject[logicalElementId] = `has error on logicalElementType: ${logicalElementType}`;
-      errorsFound.push(`has error on logicalElementType in logicalElementId: ${logicalElementId}`);
-    };
+      combineFilterStructure.logicalElements[lastLogicalElementId].nextLogicalElementId = working_logicalElementId;
+      Object.assign(combineFilterStructure.logicalElements, {
+        [working_logicalElementId]: {
+          logicalElementType: 'closeBracket',
+          previousLogicalElementId: lastLogicalElementId,
+          nextLogicalElementId: null
+        }
+      });
 
-    if (errorsFound.length > 0) {
-      return [null, errorsObject, errorsFound];
-    };
+    } else if (logicalElement.logicalElementType === "operation") {
 
-    let operations = null;
-    let operationErrorObjects = {};
-    let operationErrors = [];
+      combineFilterStructure.logicalElements[lastLogicalElementId].nextLogicalElementId = working_logicalElementId;
+      Object.assign(combineFilterStructure.logicalElements, {
+        [working_logicalElementId]: {
+          logicalElementType: "operation",
+          previousLogicalElementId: lastLogicalElementId,
+          nextLogicalElementId: null,
+          operation: logicalElement.operation
+        }
+      });
 
-    [
-      previousLogicalElementId,
-      previousLogicalElementObject,
-      operations,
-      operationErrorObjects,
-      operationErrors
-    ] = combineOperation(
-      previousLogicalElementId,
-      previousLogicalElementObject,
-      operationLogicalElementId,
-      operationLogicalElementObject,
-      nextLogicalElementId,
-      nextLogicalElementObject
-    );
-    console.log('return combineOperation: ', {
-      previousLogicalElementId,
-      previousLogicalElementObject,
-      operations,
-      operationErrors
-    });
+    } else if (logicalElement.logicalElementType === "logicalStructure") {
 
-    if (operationErrors.length > 0) {
-      Object.assign(errorsObject, operationErrorObjects);
-    };
+      if (isEmpty(combineFilterStructure)) {
 
-    if (operations !== null) {
-      Object.assign(returnLogicalElements, operations);
-      operationLogicalElementId = null;
-      operationLogicalElementObject = null;
-    } else {
-      Object.assign(returnLogicalElements, previousLogicalElementObject);
-    };
+        combineFilterStructure.objType = logicalElement.objType;
+        combineFilterStructure.initialLogicalElementId = logicalElement.initialLogicalElementId;
+        combineFilterStructure.logicalElements = logicalElement.logicalElements;
+
+      } else {
 
-  } //end iterate logicalElements
+        combineFilterStructure.logicalElements[lastLogicalElementId].nextLogicalElementId = logicalElement.initialLogicalElementId;
+        logicalElement.logicalElements[logicalElement.initialLogicalElementId].previousLogicalElementId = lastLogicalElementId;
+        Object.assign(combineFilterStructure.logicalElements, logicalElement.logicalElements);
 
-  console.log('returnLogicalElements: ', { returnLogicalElements });
+      }
 
-  let returnComplexLogicalStructure = {
-    objType: objType,
-    initialLogicalElementId: returnInitialElementId,
-    logicalElements: returnLogicalElements
-  };
+    }
 
-  return [returnComplexLogicalStructure, errorsObject, errorsFound];
+    if (logicalElement.nextLogicalElementId === null) {
+      break;
+    }
+    working_logicalElementId = logicalElement.nextLogicalElementId;
+  }
 
+  return [combineFilterStructure, errorsObject, errorsFound];
 };
 
 function combineOperation(
@@ -602,303 +558,81 @@ async function changeObjTypePath(
   requiredObjType,
   filtersStructure,
   path = null,
-  PATHCONSTANCES = null
+  indexPath = 0
 ) {
   try {
-    console.log('----- function validateSearchTypeFilterType -----', {
+    console.log('----- function changeObjTypePath -----', {
       requiredObjType,
       filtersStructure,
-      path
+      path,
+      indexPath,
     });
 
-    let filterLogicalStructure = {};
-
     let errorsObject = {};
     let errorsFound = [];
 
-    if (path !== null) {
-      console.log('-------------- continue process path --------------');
-
-      let logicalElements = {};
-      let previousLogicalElementId = null;
-      let previousLogicalElement = null;
-      let currentLogicalElementId = null;
-      let currentLogicalElement = null;
-
-      if (path.length > 1) {
-
-        for (let i = 0; i < path.length; i++) {
-
-          let pathObject = path[i];
-          let logicalStructureElements = filtersStructure.logicalElements;
-          console.log('logicalStructureElements', logicalStructureElements);
-
-          let initialLogicalElementId = filtersStructure.initialLogicalElementId;
-          console.log('initialLogicalElementId', initialLogicalElementId);
-
-          if (i + 1 === path.length) {
-            console.log(`------------------- final path: ${i} ---------------------`);
-
-            if (previousLogicalElementId !== null) {
-
-              if (checkObjType(pathObject.objType, logicalElements[previousLogicalElementId].objType) !== true) {
-                errorsFound.push('objType is not equals in structure');
-                console.log('before return: ', {
-                  filterLogicalStructure: {},
-                  errorsObject,
-                  errorsFound
-                });
-                return [{}, errorsObject, errorsFound];
-              };
+    if (indexPath > 10) {
+      errorsObject = Object.assign(errorsObject, { [filtersStructure.objType.objectType]: 'has Limit max to iterate path for change level' })
+      errorsFound.push(`this objectType: ${filtersStructure.objType.objectType} has Limit max to iterate path for change level`);
+    }
 
-              filterLogicalStructure = {
-                objType: pathObject.objType,
-                initialLogicalElementId: previousLogicalElementId,
-                logicalElements: logicalElements
-              };
-              console.log('filterLogicalStructure: ', filterLogicalStructure);
+    if (path === null) {
+      errorsObject = Object.assign(
+        errorsObject, {
+        [filtersStructure.objType.objectType]: `this objectType filtersTructure cannot change level of objectType: ${requiredObjType.objectType}`
+      });
+      errorsFound.push(`this objectType: ${filtersStructure.objType.objectType} cannot change level of objectType: ${requiredObjType.objectType}`);
+    }
 
-            } else {
-              if (checkObjType(requiredObjType, filtersStructure.objType) === true) {
-                filterLogicalStructure = filtersStructure;
-              } else {
-                errorsFound.push('objType is not equals in structure');
-                console.log('before return: ', {
-                  filterLogicalStructure: {},
-                  errorsObject,
-                  errorsFound
-                });
-                return [{}, errorsObject, errorsFound];
-              };
-            };
+    if (errorsFound.length > 0) {
+      return [null, errorsObject, errorsFound];
+    }
 
-          } else {
-            console.log(`------------------- between path: ${i} ---------------------`);
+    if (checkObjType(requiredObjType, filtersStructure.objType) !== true) {
 
-            let logicalElementsStructure = logicalStructureElements[initialLogicalElementId];
-            console.log('logicalElementsStructure', logicalElementsStructure);
+      let pathLevel = path[indexPath];
+      console.log('pathLevel: ', pathLevel);
 
-            if (previousLogicalElement !== null) {
+      let initialLogicalElementId = filtersStructure.initialLogicalElementId;
+      let initialLogicalElement = filtersStructure.logicalElements[initialLogicalElementId];
+      console.log('initialLogicalElement: ', initialLogicalElement);
 
-              currentLogicalElementId = uuidV4();
-              console.log('currentLogicalElementId: ', currentLogicalElementId);
+      let uuid_childLogicalElementId = uuidV4();
+      let childLogicalElement = {
+        logicalElementType: 'childComplexFilter',
+        previousLogicalElementId: null,
+        nextLogicalElementId: null,
 
-              currentLogicalElement = {
-                logicalElementType: 'childComplexFilter',
-                previousLogicalElementId: null,
-                nextLogicalElementId: null,
-                childLogicalElementId: filtersStructure.initialLogicalElementId,
+        childLogicalElementId: initialLogicalElementId,
+        objType: pathLevel.pathLinkType.objType,
+        pathLinkType: {
+          objType: pathLevel.objType,
+          relType: pathLevel.pathLinkType.relType,
+          direction: pathLevel.pathLinkType.direction
+        }
+      };
+      console.log('childLogicalElement: ', childLogicalElement);
 
-                objType: pathObject.pathLinkType.objType,
-                pathLinkType: {
-                  objType: pathObject.objType,
-                  relType: pathObject.pathLinkType.relType,
-                  direction: pathObject.pathLinkType.direction
-                }
-              };
-              console.log('currentLogicalElement', currentLogicalElement);
+      filtersStructure.logicalElements[initialLogicalElementId].previousLogicalElementId = uuid_childLogicalElementId;
 
-              let logicalStructure;
-              [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
-                logicalElements,
-                previousLogicalElementId,
-                previousLogicalElement,
-                currentLogicalElementId,
-                currentLogicalElement,
-                filtersStructure
-              );
-              console.log('return create child ', {
-                previousLogicalElementId,
-                previousLogicalElement,
-                logicalStructure,
-                errorsFound
-              });
-
-              logicalElements = logicalStructure;
-
-            } else {
-
-              if (logicalElementsStructure.logicalElementType === 'childComplexFilter') {
-
-                let childLogicalElementId = logicalElementsStructure.childLogicalElementId;
-                console.log('childLogicalElementId', childLogicalElementId);
-
-                if (childLogicalElementId !== null) {
-                  console.log('-------- has child filter structure --------');
-
-                  let childLogicalElement = logicalStructureElements[childLogicalElementId];
-                  console.log('childLogicalElement', childLogicalElement);
-
-                  let pathCheck = false;
-
-                  for (const pathObj of path) {
-                    if (checkObjType(childLogicalElement.objType, pathObj.objType) === true) {
-                      pathCheck = true;
-                    };
-                  };
-
-                  if (pathCheck) {
-
-                    if (logicalElementsStructure.nextLogicalElementId === null) {
-
-                      //* delete level of objType
-                      let checkChild = false;
-
-                      if (PATHCONSTANCES != null) {
-
-                        for (const objType of PATHCONSTANCES.objTypes) {
-                          if (checkObjType(objType, childLogicalElement.objType) === true) {
-                            if (!childLogicalElement.hasOwnProperty('childLogicalElementId')) {
-
-                              // let childSchema = await getObjectSchema.getObjSchemaS3WithCache(
-                              let childSchema = await getObjectSchema.getObjSchemaS3WithHierarchyShared(
-                                childLogicalElement.objType
-                              );
-                              console.log('childSchema: ', childSchema);
-
-                              if (childSchema.hasOwnProperty('extendObjType')) {
-                                if (checkObjType(requiredObjType, childSchema.extendObjType) === true) {
-                                  checkChild = false;
-                                  break;
-                                };
-                              };
-                            };
-                            checkChild = true;
-                            break;
-                          };
-                        };
-                      } else {
-                        checkChild = true;
-                      }
-
-                      if (checkChild) {
-
-                        delete filtersStructure.logicalElements[initialLogicalElementId];
-                        console.log('filtersStructure: ', filtersStructure);
-
-                        filtersStructure.objType = childLogicalElement.objType;
-                        filtersStructure.initialLogicalElementId = childLogicalElementId;
-                        filtersStructure.logicalElements[childLogicalElementId].previousLogicalElementId = null;
-                        console.log('after filtersStructure: ', filtersStructure);
-
-                        logicalElements = filtersStructure.logicalElements;
-
-                        continue;
-
-                      };
-                    };
-                  };
-
-                  currentLogicalElementId = uuidV4();
-                  console.log('currentLogicalElementId: ', currentLogicalElementId)
-
-                  currentLogicalElement = {
-                    logicalElementType: 'childComplexFilter',
-                    previousLogicalElementId: null,
-                    nextLogicalElementId: null,
-                    childLogicalElementId: filtersStructure.initialLogicalElementId,
-
-                    objType: pathObject.pathLinkType.objType,
-                    pathLinkType: {
-                      objType: pathObject.objType,
-                      relType: pathObject.pathLinkType.relType,
-                      direction: pathObject.pathLinkType.direction
-                    }
-                  };
-                  console.log('currentLogicalElement', currentLogicalElement);
-
-                  let logicalStructure = {};
-                  [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
-                    logicalElements,
-                    previousLogicalElementId,
-                    previousLogicalElement,
-                    currentLogicalElementId,
-                    currentLogicalElement,
-                    filtersStructure
-                  )
-                  console.log('return create child', {
-                    previousLogicalElementId,
-                    previousLogicalElement,
-                    logicalStructure,
-                    errorsFound
-                  });
-
-                  logicalElements = logicalStructure;
-                  console.log('logicalElements: ', logicalElements);
-
-                  // if (logicalElementsStructure.nextLogicalElementId !== null) {
-                  //  console.log("-------- no child filter structure --------", vvv);
-                  // }
-
-                } else {
-                  console.log('-------- no child filter structure --------', vvv);
-
-                }
+      filtersStructure.objType = pathLevel.pathLinkType.objType;
+      filtersStructure.initialLogicalElementId = uuid_childLogicalElementId;
+      filtersStructure.logicalElements = Object.assign({ [uuid_childLogicalElementId]: childLogicalElement }, filtersStructure.logicalElements);
+    }
 
-              } else {
+    if (checkObjType(requiredObjType, filtersStructure.objType) === false) {
 
-                currentLogicalElementId = uuidV4();
-                console.log('currentLogicalElementId: ', currentLogicalElementId);
-
-                currentLogicalElement = {
-                  logicalElementType: 'childComplexFilter',
-                  previousLogicalElementId: null,
-                  nextLogicalElementId: null,
-                  childLogicalElementId: filtersStructure.initialLogicalElementId,
-
-                  objType: pathObject.pathLinkType.objType,
-                  pathLinkType: {
-                    objType: pathObject.objType,
-                    relType: pathObject.pathLinkType.relType,
-                    direction: pathObject.pathLinkType.direction
-                  }
-                };
-                console.log('currentLogicalElement', currentLogicalElement);
-
-                let logicalStructure = {};
-                // change function name ==> set logicalElementId
-                [previousLogicalElementId, previousLogicalElement, logicalStructure, errorsFound] = createChildComplexFilterStructure(
-                  logicalElements,
-                  previousLogicalElementId,
-                  previousLogicalElement,
-                  currentLogicalElementId,
-                  currentLogicalElement,
-                  filtersStructure
-                )
-                console.log('return create child', {
-                  previousLogicalElementId,
-                  previousLogicalElement,
-                  logicalStructure,
-                  errorsFound
-                });
-                logicalElements = logicalStructure;
-              };
-            };
-          };
-        };
-      } else {
-        console.log('------------ path euals 1 -----------');
-        console.log('pathObject', path[0]);
+      filtersStructure = await changeObjTypePath(
+        requiredObjType,
+        filtersStructure,
+        path,
+        indexPath + 1
+      );
+      console.log('filtersStructure: ', filtersStructure);
 
-        if (checkObjType(requiredObjType, filtersStructure.objType) === true) {
-          filterLogicalStructure = filtersStructure;
-        } else {
-          errorsObject = {
-            [requiredObjType.objectType]: `is not equals objType in filter structure: objType: ${filtersStructure.objType.objectType}`
-          };
-          errorsFound.push(`${requiredObjType.objectType} is not equals objType in filter structure: objType: ${filtersStructure.objType.objectType}`);
-          return [filterLogicalStructure, errorsObject, errorsFound];
-        };
-      };
-    };
+    }
 
-    console.log('before return filterLogicalStructure: ', {
-      path,
-      filterLogicalStructure,
-      errorsObject,
-      errorsFound
-    });
-    return [filterLogicalStructure, errorsObject, errorsFound];
+    return [filtersStructure, errorsObject, errorsFound];
 
   } catch (err) {
     console.log('error ValidateSearchTypeFilterType: ', err)
@@ -906,56 +640,6 @@ async function changeObjTypePath(
   };
 
 };
-//###################################################################################################################################################################################
-
-
-
-
-function createChildComplexFilterStructure(
-  logicalElements,
-  previousLogicalElementId,
-  previousLogicalElement,
-  currentLogicalElementId,
-  currentLogicalElement,
-  filtersStructure
-) {
-  console.log('createChildComplexFilterStructure: ', {
-    logicalElements,
-    previousLogicalElementId,
-    previousLogicalElement,
-    currentLogicalElementId,
-    currentLogicalElement,
-    filtersStructure
-  });
-
-  let errorsFound = [];
-
-  if (!currentLogicalElement) {
-    errorsFound.push('no current logical element to process');
-    return [previousLogicalElementId, previousLogicalElement, logicalElements, errorsFound];
-  };
-
-  if (!previousLogicalElement) {
-    filtersStructure.logicalElements[filtersStructure.initialLogicalElementId].previousLogicalElementId = currentLogicalElementId;
-    logicalElements = Object.assign({ [currentLogicalElementId]: currentLogicalElement }, logicalElements, filtersStructure.logicalElements);
-  } else {
-
-    currentLogicalElement.childLogicalElementId = previousLogicalElementId;
-    console.log('currentLogicalElement', currentLogicalElement);
-
-    logicalElements[previousLogicalElementId].previousLogicalElementId = currentLogicalElementId;
-    console.log('logicalElements', logicalElements);
-
-    logicalElements = Object.assign({ [currentLogicalElementId]: currentLogicalElement }, logicalElements);
-    console.log('after logicalElements', logicalElements);
-
-  };
-
-  previousLogicalElementId = currentLogicalElementId;
-  previousLogicalElement = currentLogicalElement;
-
-  return [previousLogicalElementId, previousLogicalElement, logicalElements, errorsFound];
-};
 
 async function findObjTypePathToAnotherObjType(
   fromObjType,
@@ -1157,10 +841,9 @@ export default {
   initSchemaFn,
 
   combineLogicalStructure,
-  // combineOperation,
-  // combineLogicalElements,
 
   checkAndCreateBracket,
+  createLogicalElementBracket,
 
   changeObjTypePath,
   findObjTypePathToAnotherObjType