@izara_frontend/shared-complex-filter 1.0.1

package/src/function/complexFilterFunction.js

@@ -0,0 +1,28 @@
+export function successTraversal(state, action) {
+  const { parentOutputId, traversalLinkStepsObj } = action.payload;
+
+  state[
+    parentOutputId
+  ].currentValues.pageOutputMainConfigUseCase.traversalSteps = {
+    ...state[parentOutputId].currentValues.pageOutputMainConfigUseCase
+      .traversalSteps,
+    ...traversalLinkStepsObj,
+  };
+}
+
+export function successFilterElement(state, action) {
+  const { parentOutputId, initialLogicalElementId, logicalElements } =
+    action.payload;
+
+  state[
+    parentOutputId
+  ].currentValues.pageOutputMainConfigUseCase.initialLogicalElementId =
+    initialLogicalElementId;
+  state[
+    parentOutputId
+  ].currentValues.pageOutputMainConfigUseCase.logicalElements = {
+    ...state[parentOutputId].currentValues.pageOutputMainConfigUseCase
+      .logicalElements,
+    ...logicalElements,
+  };
+}

package/src/function/createActionLibCreateLinkStepAndComplexFilter.js

@@ -0,0 +1,47 @@
+import { current, createEntityAdapter, createAction } from "@reduxjs/toolkit";
+
+//--------------------------valueUserTag----------------------------------------
+import {
+  valueUserTagCreate,
+  validateValueUserTagNotUsed,
+} from "./valueUserTagFunction";
+
+export const valueUserTagCreateConfig = createAction(
+  "valueUserTagCreateConfig",
+);
+
+export const validateValueUserTagNotUsedConfig = createAction(
+  "validateValueUserTagNotUsedConfig",
+);
+
+//-------------------------------complexFilterFunction-----------------------------------
+
+import {
+  successTraversal,
+  // successFilterElement,
+} from "./complexFilterFunction";
+
+export const successTraversalConfig = createAction("successTraversalConfig");
+// export const successFilterElementConfig = createAction(
+//   "successFilterElementConfig",
+// );
+
+//--------------------------------linkStepFunctionAndUseCase-----------------------------------
+// import { successRequiredData } from "./linkStepFunction";
+
+// export const successRequiredDataConfig = createAction(
+//   "successRequiredDataConfig",
+// );
+
+export const sendExtraReducerLibCreateLinkStepAndComplexFilter = (builder) => {
+  //----------------------------valueUserTag---------------------------------------
+  builder.addCase(valueUserTagCreateConfig, valueUserTagCreate);
+  builder.addCase(
+    validateValueUserTagNotUsedConfig,
+    validateValueUserTagNotUsed,
+  );
+  //----------------------------------complexFilterFunction----------------------------
+  builder.addCase(successTraversalConfig, successTraversal);
+  // builder.addCase(successFilterElementConfig, successFilterElement);
+  // builder.addCase(successRequiredDataConfig, successRequiredData);
+};

package/src/function/linkStepFunction.js

@@ -0,0 +1,38 @@
+export function successRequiredData(state, action) {
+  const {
+    parentOutputId,
+    linkSteps,
+    initialObjType,
+    nameLinkStepObject,
+    dataType,
+    linkStepsArr,
+  } = action.payload;
+
+  if (linkStepsArr === undefined) {
+    linkStepsArr = [];
+    for (const index in linkSteps) {
+      let linkStepObj = _.cloneDeep(linkSteps[index]);
+
+      let hashRequiredData = hash(linkStepObj);
+
+      state[
+        parentOutputId
+      ].currentValues.pageOutputMainConfigUseCase.requiredDataLinkSteps[
+        hashRequiredData
+      ] = linkStepObj;
+
+      linkStepsArr.push(hashRequiredData);
+    }
+  }
+
+  let requiredDataLinkStepObjects = {
+    initialObjType: initialObjType,
+    linkSteps: linkStepsArr,
+  };
+
+  state[
+    parentOutputId
+  ].currentValues.pageOutputMainConfigUseCase.requiredDataLinkStepObjects[
+    nameLinkStepObject
+  ] = requiredDataLinkStepObjects;
+}

package/src/function/valueUserTagFunction.js

@@ -0,0 +1,188 @@
+import { current, createEntityAdapter, createAction } from "@reduxjs/toolkit";
+
+export const valueUserTagCreate = (state, action) => {
+  const { parentOutputId, objCreateValueUserTag } = action.payload;
+
+  console.log(
+    "objCreateValueUserTag:rdfsdgfhfb ",
+    parentOutputId,
+    objCreateValueUserTag,
+  );
+  state[parentOutputId].currentValues.pageOutputMainConfigUseCase.valueUserTags[
+    objCreateValueUserTag.keyName
+  ] = { defaultValue: objCreateValueUserTag.defaultValue };
+};
+
+export const validateValueUserTagNotUsed = (state, action) => {
+  //linkstep
+  for (const linkStepId in state[parentOutputId].currentValues
+    .pageOutputMainConfigUseCase.linkSteps) {
+    console.log("linkStepId: ", linkStepId);
+  }
+};
+
+// function scanLogicalElements(set, logicalElements) {
+//   if (!logicalElements) return;
+
+//   Object.values(logicalElements).forEach((el) => {
+//     addTagsFromObjectValues(set, el.partitionKeyValueUserTags);
+//     addTagsFromObjectValues(set, el.sortKeyValueUserTags);
+
+//     if (el.conditionalFieldValues) {
+//       el.conditionalFieldValues.forEach((cond) => {
+//         addTags(set, cond.includeValueUserTags);
+//         addTags(set, cond.excludeValueUserTags);
+//       });
+//     }
+
+//     addTagsFromObjectValues(set, el.requestProperties);
+//   });
+// }
+
+// function scanTraversalSteps(set, traversalSteps) {
+//   if (!traversalSteps) return;
+
+//   Object.values(traversalSteps).forEach((step) => {
+//     if (step.fieldValueUserTags) {
+//       step.fieldValueUserTags.forEach((obj) => {
+//         addTagsFromObjectValues(set, obj);
+//       });
+//     }
+//   });
+// }
+
+// function scanSortFields(set, sortFields) {
+//   if (!sortFields) return;
+
+//   sortFields.forEach((sf) => {
+//     addTags(set, sf.sortByValueUserTags);
+//   });
+// }
+
+// function scanCombinations(set, combinations) {
+//   if (!combinations) return;
+
+//   Object.values(combinations).forEach((c) => {
+//     scanLogicalElements(set, c.logicalElements);
+//   });
+// }
+
+//------------------------
+const addTags = (usedSet, tagKeys, arr) => {
+  console.log(
+    "usedSet, tagKeys, arr:addTags:xzxzxawffbbc ",
+    usedSet,
+    tagKeys,
+    arr,
+  );
+  if (!Array.isArray(arr)) return;
+
+  for (const v of arr) {
+    addTags(usedSet, tagKeys, v);
+  }
+};
+
+const addTagsFromObjectValues = (usedSet, tagKeys, obj) => {
+  if (!obj) return;
+
+  for (const v of Object.values(obj)) {
+    addTags(usedSet, tagKeys, v);
+  }
+};
+
+function scanLogicalElements(usedSet, tagKeys, logicalElements) {
+  console.log(
+    "logicalElements:dxczxcvasrfdwaefasdf ",
+    usedSet,
+    tagKeys,
+    logicalElements,
+  );
+  if (!logicalElements) return;
+
+  for (const el of Object.values(logicalElements)) {
+    addTagsFromObjectValues(usedSet, tagKeys, el.partitionKeyValueUserTags);
+
+    addTagsFromObjectValues(usedSet, tagKeys, el.sortKeyValueUserTags);
+
+    // if (el.conditionalFieldValues) {
+    //   for (const cond of el.conditionalFieldValues) {
+    //     addTags(usedSet, tagKeys, cond.includeValueUserTags);
+
+    //     addTags(usedSet, tagKeys, cond.excludeValueUserTags);
+    //   }
+    // }
+
+    addTagsFromObjectValues(usedSet, tagKeys, el.requestProperties);
+  }
+}
+
+function scanTraversalSteps(usedSet, tagKeys, traversalSteps) {
+  if (!traversalSteps) return;
+
+  for (const step of Object.values(traversalSteps)) {
+    if (!step.fieldValueUserTags) continue;
+
+    for (const obj of step.fieldValueUserTags) {
+      addTagsFromObjectValues(usedSet, tagKeys, obj);
+    }
+  }
+}
+
+function scanRequiredDataLinkSteps(usedSet, tagKeys, steps) {
+  if (!steps) return;
+
+  for (const step of Object.values(steps)) {
+    addTagsFromObjectValues(usedSet, tagKeys, step.requestProperties);
+    console.log("step: dfcvxbcxb", step);
+    if (step.filterElements) {
+      scanLogicalElements(
+        usedSet,
+        tagKeys,
+        step.filterElements.logicalElements,
+      );
+    }
+
+    if (step.sortFields) {
+      for (const sf of step.sortFields) {
+        addTags(usedSet, tagKeys, sf.sortByValueUserTags);
+      }
+    }
+
+    addTags(usedSet, tagKeys, step.comparisonValue);
+  }
+}
+function scanSortFields(usedSet, tagKeys, sortFields) {
+  if (!sortFields) return;
+
+  for (const sf of sortFields) {
+    addTags(usedSet, tagKeys, sf.sortByValueUserTags);
+  }
+}
+function scanCombinations(usedSet, tagKeys, combinations) {
+  if (!combinations) return;
+
+  for (const combo of Object.values(combinations)) {
+    scanLogicalElements(usedSet, tagKeys, combo.logicalElements);
+  }
+}
+
+export function findUsedUserTagsFast(param) {
+  const used = new Set();
+
+  const tagKeys = new Set(Object.keys(param.valueUserTags));
+
+  scanLogicalElements(used, tagKeys, param.logicalElements);
+
+  scanTraversalSteps(used, tagKeys, param.traversalSteps);
+
+  scanRequiredDataLinkSteps(used, tagKeys, param.requiredDataLinkSteps);
+
+  scanSortFields(used, tagKeys, param.sortFields);
+
+  scanCombinations(used, tagKeys, param.complexFilterCombinations);
+
+  scanCombinations(used, tagKeys, param.perParentCombinations);
+
+  console.log("used:wsdxcvzvxcv ", used, tagKeys);
+  return used;
+}

package/src/index.js

@@ -0,0 +1,9 @@
+export { MainCaseUseConditionAndMultipleIdentifersComponent, ConditionLinkStepAndMultipleIdentifersComponent } from "./complexFilterMain/mainCaseUseConditionAndMultipleIdentifersComponent.jsx";
+export { ModalComplexFilterComponent } from "./complexFilterMain/modalComplexFilterComponent.jsx";
+export { ModalLinkStepsComponent } from "./linkSteps/modalLinkStepsComponent.jsx";
+export { UserTagsSelectAndCreateComponent } from "./valueUserTags/valueUserTagsComponent.jsx";
+export { FieldNameComponent } from "./valueUserTags/fieldNameComponent.jsx";
+
+export { sendExtraReducerLibCreateLinkStepAndComplexFilter } from "./function/createActionLibCreateLinkStepAndComplexFilter";
+export { successFilterElement } from "./function/complexFilterFunction";
+export { successRequiredData } from "./function/linkStepFunction";