@truedat/dq 4.28.5 → 4.29.0

package/src/components/ruleImplementationForm/ValueConditions.js

@@ -7,19 +7,19 @@ import FiltersFormGroup from "./FiltersFormGroup";
 
 export const ValueConditions = ({
   allOperators,
+  operators,
   composeValue,
   onChange,
   population = [],
   parentStructures,
-  getOperators,
-  getOperatorValue,
   scope,
   siblings,
 }) => {
-  const onStructureChange = (index, value) => {
+  const onStructureChange = (index, value, opts) => {
     const structure = {
+      ..._.pick(["field_type", "name", "data_structure_id"])(value),
       id: value?.data_structure_id,
-      ..._.pick(["field_type", "name"])(value),
+      opts,
     };
     const updatedCondition = { structure };
     const modifiedPopulation = replaceAt(index, updatedCondition)(population);
@@ -70,8 +70,6 @@ export const ValueConditions = ({
         <Grid.Column width={14}>
           <FiltersFormGroup
             clause={clause}
-            getOperators={getOperators}
-            getOperatorValue={getOperatorValue}
             index={index}
             onOperatorChange={onOperatorChange}
             onStructureChange={onStructureChange}
@@ -79,6 +77,7 @@ export const ValueConditions = ({
             parentStructures={parentStructures}
             scope={scope}
             siblings={siblings}
+            operators={operators}
           />
         </Grid.Column>
         <Grid.Column width={2} floated={"right"}>
@@ -100,9 +99,8 @@ export const ValueConditions = ({
 
 ValueConditions.propTypes = {
   allOperators: PropTypes.array,
+  operators: PropTypes.array,
   composeValue: PropTypes.func,
-  getOperators: PropTypes.func,
-  getOperatorValue: PropTypes.func,
   population: PropTypes.array,
   onChange: PropTypes.func,
   parentStructures: PropTypes.array,

package/src/components/ruleImplementationForm/__tests__/__snapshots__/FiltersFormGroup.spec.js.snap

@@ -6,9 +6,15 @@ exports[`<FiltersFormGroup /> matches the latest snapshot 1`] = `
     class="fields force-margin-bottom"
     style="display: none;"
   >
-    <div
-      class="four wide field"
-    />
+    <div>
+      <div
+        class="flex-row-align-end"
+      >
+        <div
+          class="field"
+        />
+      </div>
+    </div>
     <div
       class="field"
     />

package/src/components/ruleImplementationForm/__tests__/__snapshots__/FiltersGroup.spec.js.snap

@@ -12,9 +12,15 @@ exports[`<FiltersGroup /> matches the latest snapshot when siblings provided 1`]
       <div
         class="fields force-margin-bottom"
       >
-        <div
-          class="four wide field"
-        />
+        <div>
+          <div
+            class="flex-row-align-end"
+          >
+            <div
+              class="field"
+            />
+          </div>
+        </div>
         <div
           class="field"
         />

package/src/components/ruleImplementationForm/__tests__/__snapshots__/ValueConditions.spec.js.snap

@@ -12,9 +12,15 @@ exports[`<ValueConditions /> matches the latest snapshot when siblings provided
       <div
         class="fields force-margin-bottom"
       >
-        <div
-          class="four wide field"
-        />
+        <div>
+          <div
+            class="flex-row-align-end"
+          >
+            <div
+              class="field"
+            />
+          </div>
+        </div>
         <div
           class="field"
         />

package/src/components/ruleImplementationForm/operators.js

@@ -0,0 +1,82 @@
+import _ from "lodash/fp";
+
+export default (operators, type, nested, scope, formatMessage) => {
+  const filterFieldType = (operators) =>
+    nested ? _.filter((o) => o?.value_type !== "field")(operators) : operators;
+
+  const withValueType = (value, valueType) =>
+    valueType ? `${value}.${valueType}` : value;
+
+  const getOptions = (operators) =>
+    _.flow(
+      _.groupBy("group"),
+      _.reduce.convert({ cap: false })((acc, v, k) => {
+        return _.isNil(k) || k === "undefined" || _.size(v) <= 1
+          ? [...acc, ...v]
+          : [...acc, { label: k, options: v }];
+      }, []),
+      _.sortBy(["label"]),
+      _.map(renderOperatorOptions)
+    )(operators);
+
+  const renderOperatorOptions = (operator) =>
+    _.has("options")(operator)
+      ? {
+          icon: "random",
+          label: formatMessage({
+            id: `ruleImplementation.operator.group.${operator.label}`,
+          }),
+          options: _.map(renderOperatorOption)(operator.options),
+        }
+      : renderOperatorOption(operator);
+
+  const renderOperatorOption = (operator) => ({
+    text: formatMessage({
+      id: withValueType(
+        `ruleImplementation.operator.${operator.name}`,
+        operator.value_type
+      ),
+    }),
+    id: operator.id,
+    value: withValueType(`${type}.${operator.name}`, operator.value_type),
+  });
+  const operatorsOptions = !type
+    ? []
+    : _.flow(
+        _.pick([type, "any"]),
+        _.values,
+        _.map(_.prop("operators")),
+        _.flatten,
+        _.filter(
+          ({ scope: op_scope }) =>
+            _.isNull(op_scope) ||
+            _.isEmpty(op_scope) ||
+            _.isEqual(scope)(op_scope)
+        ),
+        filterFieldType,
+        getOptions
+      )(operators);
+
+  const getOperatorValue = (row) =>
+    _.has("operator")(row) && !_.isEmpty(row.operator)
+      ? withValueType(
+          `${type}.${_.path("operator.name")(row)}`,
+          _.path("operator.value_type")(row)
+        )
+      : null;
+
+  const typeCastModifiers = _.flow(
+    _.toPairs,
+    _.map(([key, value]) =>
+      _.map((m) => ({ ...m, sourceType: key }))(value.modifiers || [])
+    ),
+    _.flatten,
+    _.filter(({ cast_as }) => cast_as === type)
+  )(operators);
+
+  return {
+    operatorsOptions,
+    getOperatorValue,
+    typeCastModifiers,
+  };
+};

package/src/selectors/getRuleImplementationOperators.js

@@ -287,6 +287,7 @@ export const getRuleImplementationOperators = createSelector(
         (acc, value, key) =>
           _.set(key, {
             operators: _.map((o) => _.omit(["category"])(o))(value),
+            modifiers: _.propOr([], `${key}.modifiers`)(operators),
           })(acc),
         {}
       )