@truedat/dq 8.10.8 → 8.11.2

package/src/selectors/getParsedEvents.js

@@ -1,14 +1,15 @@
 import _ from "lodash/fp";
 import { createSelector } from "reselect";
 
-const FIELDS_WITHOUT_VALUE_TYPES = [
-  "url",
-  "table",
-  "system",
-  "image",
-  "markdown",
+const FIELDS_WITHOUT_VALUE_TYPES = ["table", "system", "image", "markdown"];
+const ADD_ON_UPDATE_FIELDS = [
+  "dataset",
+  "populations",
+  "validation",
+  "segments",
+  "description",
+  "business_concept",
 ];
-
 const getEvents = ({ events }) => events;
 
 const getRuleTemplate = (state) =>
@@ -21,85 +22,386 @@ const getImplementationTemplate = (state) =>
     _.getOr([], "allTemplates", state),
   );
 
-const getFieldsWithoutValue = (template) =>
-  _.flow(
-    _.getOr([], "content"),
-    _.map(_.getOr([], "fields")),
-    _.flatten,
-    _.filter((f) => _.includes(_.prop("type")(f))(FIELDS_WITHOUT_VALUE_TYPES)),
-    _.map(_.prop("name")),
-  )(template);
+const shouldHideValue = (entry, section) => {
+  if (!entry) return false;
+  if (
+    section === "removed" &&
+    entry.type &&
+    FIELDS_WITHOUT_VALUE_TYPES.includes(entry.type)
+  ) {
+    return true;
+  }
+  return false;
+};
 
-const withoutTargetAction = (action, field, fieldsWithoutValue) =>
-  _.includes(field)(fieldsWithoutValue) ? `${action}_without_target` : action;
+const contentActionExtra = (section, fieldKey, fieldTypeMap) => {
+  const fieldType = _.get(fieldKey, fieldTypeMap);
+  return _.includes(fieldType)(FIELDS_WITHOUT_VALUE_TYPES)
+    ? `${section}_without_target`
+    : section;
+};
+
+const getFieldLabel = (field, fields) =>
+  _.flow(
+    _.find((f) => _.prop("name")(f) == field),
+    _.defaultTo({}),
+    _.prop("label"),
+  )(fields) || field;
 
-const unwrapFieldValue = (fieldValue) =>
-  _.isObject(fieldValue) && !_.isNull(fieldValue) && _.has("value", fieldValue)
-    ? fieldValue.value
-    : fieldValue;
+const isNullOrEmpty = (value) =>
+  !_.isNumber(value) &&
+  (!value || _.isEmpty(value) || (value.length === 1 && _.isEmpty(value[0])));
 
 const transformFieldFormat = (field) =>
   _.isBoolean(field) ? _.toString(field) : field;
 
-const getContentChanges = (action, fields, fieldsWithoutValue) =>
-  _.flow(
-    _.toPairs,
-    _.map(([field, rawValue]) => ({
-      field,
-      action: withoutTargetAction(action, field, fieldsWithoutValue),
-      value: transformFieldFormat(unwrapFieldValue(rawValue)),
-    })),
-  )(fields || {});
-
-const getImplementationUpdatedEvent = (e) => {
-  const { payload } = e;
-  if (!payload) return { ...e, payload: [] };
+const transformRulePayloadValueFormat = (payload, field) => {
+  const sectionFields = ["dataset", "populations", "validation", "segments"];
+
+  if (sectionFields.includes(field)) {
+    return isNullOrEmpty(payload[field]) ? null : payload[field];
+  }
 
+  switch (field) {
+    case "business_concept":
+      return payload.business_concept?.name || null;
+    default:
+      return payload[field];
+  }
+};
+
+const selectPayloadAction = (baseAction, field, value) => {
+  const baseFields = [
+    "business_concept",
+    "description",
+    "df_name",
+    "name",
+    "goal",
+    "minimum",
+    "result_type",
+    "implementation_key",
+    "rule_name",
+    "dataset",
+    "populations",
+    "validation",
+    "segments",
+  ];
+  if (
+    _.includes(baseAction)(["changed", "updated"]) &&
+    _.includes(field)(baseFields) &&
+    isNullOrEmpty(value)
+  ) {
+    return field + "_removed_without_value";
+  } else if (
+    _.includes(baseAction)(["changed", "updated"]) &&
+    _.includes(field)([...baseFields, "executable", "active"])
+  ) {
+    return field + "_updated";
+  } else if (
+    baseAction == "created" &&
+    _.includes(field)(baseFields) &&
+    isNullOrEmpty(value)
+  ) {
+    return null;
+  } else if (
+    baseAction == "created" &&
+    _.includes(field)([...baseFields, "executable", "active"])
+  ) {
+    return field + "_added";
+  } else if (baseAction == "created") {
+    return "added";
+  }
+  return "changed";
+};
+
+const checkDomainInPayload = (payload, baseAction) => {
   // eslint-disable-next-line fp/no-let
   let field_config = [];
+  const { new_domain, old_domain, domain_id, event_via } = payload;
 
-  const { new_domain } = payload;
-  const { old_domain } = payload;
-
-  if (new_domain) {
+  if (new_domain && !old_domain) {
+    const { name: domain_new_name } = new_domain;
+    // eslint-disable-next-line fp/no-mutation
+    field_config = _.concat({
+      action: baseAction,
+      action_extra: "domain_added_with_name",
+      field: domain_new_name,
+      event_via,
+    })(field_config);
+  } else if (new_domain && old_domain) {
     const { name: domain_new_name } = new_domain;
     const { name: domain_old_name } = old_domain;
     // eslint-disable-next-line fp/no-mutation
     field_config = _.concat({
-      action: "domain_updated_with_names",
+      action: baseAction,
+      action_extra: "domain_updated_with_names",
       field: domain_old_name,
       value: domain_new_name,
+      event_via,
     })(field_config);
-  } else {
+  } else if (domain_id && !new_domain) {
     // eslint-disable-next-line fp/no-mutation
     field_config = _.concat({
-      action: "updated",
-      field: _.path("payload.implementation_key")(e),
+      action: baseAction,
+      action_extra:
+        baseAction == "created"
+          ? "domain_added_with_id"
+          : "domain_updated_with_id",
+      field: domain_id,
+      event_via,
     })(field_config);
   }
+  return field_config;
+};
+
+const normalizeUrlArrayValue = (val) => {
+  if (_.isArray(val)) {
+    if (
+      _.every(
+        (v) => _.isObject(v) && _.has("url_name")(v) && _.has("url_value")(v),
+      )(val)
+    ) {
+      return _.flow(
+        _.map((v) => `[${v.url_name}] (${v.url_value})`),
+        _.join(" ; "),
+      )(val);
+    }
+    return `[${val.map((item) => (typeof item === "string" ? item : JSON.stringify(item))).join(", ")}]`;
+  }
+  return val;
+};
+
+const maybeExtractContentValue = _.cond([
+  [_.has("value"), _.prop("value")],
+  [_.T, _.identity],
+]);
+
+const getTemplateFields = (template) =>
+  _.flow(
+    _.getOr([], "content"),
+    _.map(_.getOr([], "fields")),
+    _.flatten,
+  )(template);
+
+const formatContentValue = (entry, section) => {
+  if (entry === "") return "";
+  if (!entry) return null;
+  if (shouldHideValue(entry, section)) {
+    return null;
+  }
+  return transformFieldFormat(
+    normalizeUrlArrayValue(maybeExtractContentValue(entry)),
+  );
+};
+
+const getContentActionExtra = (section, fieldKey, fieldTypeMap, entry) => {
+  const baseExtra = contentActionExtra(section, fieldKey, fieldTypeMap);
+  if (
+    section === "removed" &&
+    entry?.type &&
+    FIELDS_WITHOUT_VALUE_TYPES.includes(entry.type)
+  ) {
+    return "removed_without_target";
+  }
+  return baseExtra;
+};
+
+const buildEventPayload = (
+  payload,
+  template,
+  baseAction,
+  baseActionExtra,
+  contentSections,
+) => {
+  const { event_via, content, df_content } = payload;
+
+  const templateFields = getTemplateFields(template);
+
+  const fieldTypeMap = _.fromPairs(
+    _.map((f) => [f.name, f.type])(templateFields),
+  );
+
+  const fieldsToOmit = [
+    "updated_by",
+    "updated_at",
+    "content",
+    "df_content",
+    "event_via",
+    "domain_ids",
+    "domain_id",
+    "new_domain",
+    "old_domain",
+    "rule_id",
+  ];
+
+  const content_any = df_content || content;
+
+  const baseChanges = _.flow(
+    _.omit(fieldsToOmit),
+    _.keys,
+    _.flatMap((field) => {
+      const addedFields = ADD_ON_UPDATE_FIELDS.map((f) => f + "_added");
+      if (addedFields.includes(field)) {
+        const baseField = field.replace(/_added$/, "");
+        const value =
+          field === "business_concept_added" && _.isObject(payload[field])
+            ? _.get("name", payload[field])
+            : payload[field];
+
+        return {
+          field: baseField,
+          value,
+          action: baseAction,
+          action_extra: field,
+          event_via,
+        };
+      }
+      if (field === "business_concept_removed") {
+        const concept = payload[field];
+        return {
+          field: "business_concept",
+          value: concept?.name || null,
+          action: baseAction,
+          action_extra: "business_concept_removed",
+          event_via,
+        };
+      }
+      const value = transformRulePayloadValueFormat(payload, field);
+      return {
+        field,
+        value,
+        action: baseAction,
+        action_extra: selectPayloadAction(baseAction, field, value),
+        event_via,
+      };
+    }),
+  )(payload);
+
+  const domainChanges = checkDomainInPayload(payload, baseAction);
+
+  // eslint-disable-next-line fp/no-let
+  let field_config = _.concat(domainChanges, baseChanges);
+
+  if (content_any) {
+    if (contentSections?.length) {
+      const contentChanges = _.flatMap((section) => {
+        const entries = _.getOr({}, section, content_any);
+        return _.map((key) => {
+          const entry = entries[key];
+          return {
+            action: baseAction,
+            action_extra: getContentActionExtra(
+              section,
+              key,
+              fieldTypeMap,
+              entry,
+            ),
+            field: getFieldLabel(key, templateFields),
+            value: formatContentValue(entry, section),
+            event_via,
+          };
+        })(Object.keys(entries));
+      })(contentSections);
+      // eslint-disable-next-line fp/no-mutation
+      field_config = _.concat(field_config, contentChanges);
+    } else {
+      const contentChanges = _.map((key) => {
+        const entry = content_any[key];
+        return {
+          action: baseAction,
+          action_extra: getContentActionExtra(
+            baseActionExtra,
+            key,
+            fieldTypeMap,
+            entry,
+          ),
+          field: getFieldLabel(key, templateFields),
+          value: formatContentValue(entry, baseActionExtra),
+          event_via,
+        };
+      })(Object.keys(content_any));
+      // eslint-disable-next-line fp/no-mutation
+      field_config = _.concat(field_config, contentChanges);
+    }
+  }
+
+  return field_config;
+};
+
+const getImplementationUpdatedEvent = ({ payload, ...e }, template) => {
+  if (!payload) return { ...e, payload: [] };
+  const field_config = buildEventPayload(
+    payload,
+    template,
+    "updated",
+    "updated",
+    ["changed", "added", "removed"],
+  );
+  return { ...e, payload: field_config };
+};
+
+const getImplementationChangedEvent = ({ payload, ...e }, template) => {
+  if (!payload) return { ...e, payload: [] };
+  const field_config = buildEventPayload(
+    payload,
+    template,
+    "changed",
+    "changed",
+    ["changed", "added", "removed"],
+  );
+  return { ...e, payload: field_config };
+};
+
+const getImplementationCreatedEvent = ({ payload, ...e }, template) => {
+  if (!payload) return { ...e, payload: [] };
+  const field_config = buildEventPayload(
+    payload,
+    template,
+    "created",
+    "added",
+    null,
+  );
+  return { ...e, payload: field_config };
+};
+
+const getRuleUpdatedEvent = ({ payload, ...e }, template) => {
+  if (!payload) return { ...e, payload: [] };
+  const field_config = buildEventPayload(
+    payload,
+    template,
+    "changed",
+    "changed",
+    ["changed", "added", "removed"],
+  );
+  return { ...e, payload: field_config };
+};
+
+const getRuleCreatedEvent = ({ payload, ...e }, template) => {
+  if (!payload) return { ...e, payload: [] };
+  const field_config = buildEventPayload(
+    payload,
+    template,
+    "created",
+    "added",
+    null,
+  );
   return { ...e, payload: field_config };
 };
 
 const getParsedEvents = createSelector(
   [getEvents, getRuleTemplate, getImplementationTemplate],
   (events, ruleTemplate, implementationTemplate) => {
-    const ruleFieldsWithoutValue = getFieldsWithoutValue(ruleTemplate);
-    const implementationFieldsWithoutValue = getFieldsWithoutValue(
-      implementationTemplate,
-    );
-
     return _.map((d) => {
+      const event_via = _.path("payload.event_via")(d);
+      const isImplementationEvent = d.event.startsWith("implementation_");
+      const template = isImplementationEvent
+        ? implementationTemplate
+        : ruleTemplate;
+
       switch (d.event) {
         case "implementation_created":
-          return {
-            ...d,
-            payload: [
-              {
-                field: _.path("payload.rule_name")(d),
-                action: "created",
-              },
-            ],
-          };
+          return getImplementationCreatedEvent(d, template);
+
         case "implementation_moved":
           return {
             ...d,
@@ -107,9 +409,12 @@ const getParsedEvents = createSelector(
               {
                 field: _.path("payload.rule_name")(d),
                 action: "moved",
+                action_extra: "moved",
+                event_via,
               },
             ],
           };
+
         case "implementation_restored":
           return {
             ...d,
@@ -117,104 +422,103 @@ const getParsedEvents = createSelector(
               {
                 field: _.path("payload.implementation_key")(d),
                 action: "restored",
+                event_via,
               },
             ],
           };
+
         case "implementation_deleted":
-          return {};
-        case "implementation_deprecated":
           return {
             ...d,
             payload: [
               {
                 field: _.path("payload.implementation_key")(d),
-                action: "deprecated",
+                action: "deleted",
+                event_via,
               },
             ],
           };
-        case "implementation_changed": {
-          const dfContent = _.getOr({}, "payload.df_content")(d);
+
+        case "implementation_changed":
+          return getImplementationChangedEvent(d, template);
+
+        case "implementation_status_updated": {
+          const new_status = _.path("payload.status")(d);
+          const version = _.path("payload.version")(d);
           return {
             ...d,
             payload: [
-              ...getContentChanges(
-                "changed",
-                dfContent.changed,
-                implementationFieldsWithoutValue,
-              ),
-              ...getContentChanges(
-                "added",
-                dfContent.added,
-                implementationFieldsWithoutValue,
-              ),
-              ...getContentChanges(
-                "removed",
-                dfContent.removed,
-                implementationFieldsWithoutValue,
-              ),
+              {
+                value: version,
+                action: new_status,
+                event_via,
+                ...(version &&
+                  new_status === "draft" && {
+                    action_extra: "created_version",
+                  }),
+              },
             ],
           };
         }
-        case "implementation_status_updated":
+
+        case "implementation_updated":
+          return getImplementationUpdatedEvent(d, template);
+
+        case "implementation_structure_created":
+        case "implementation_structure_deleted": {
+          const suffix =
+            d.event === "implementation_structure_created"
+              ? "created"
+              : "deleted";
           return {
             ...d,
             payload: [
               {
-                field: _.path("payload.implementation_key")(d),
-                action: _.path("payload.status")(d),
+                field: d.payload.type,
+                value: d.payload.data_structure_name,
+                action: `relation_${suffix}`,
+                action_extra: `relation_${suffix}_data_structure`,
+                event_via,
               },
             ],
           };
+        }
 
-        case "implementation_updated":
-          return getImplementationUpdatedEvent(d);
-
-        case "rule_created":
+        case "relation_created":
+        case "relation_deprecated": {
+          const suffix =
+            d.event === "relation_created" ? "created" : "deprecated";
           return {
             ...d,
             payload: [
               {
-                field: _.path("payload.name")(d),
-                action: "created",
+                field: d.payload.target_type,
+                value: d.payload.target_name,
+                action: `relation_${suffix}`,
+                action_extra: `relation_${suffix}_${d.payload.target_type}`,
+                event_via,
               },
             ],
           };
-        case "rule_updated": {
-          const content = _.getOr({}, "payload.content")(d);
+        }
+
+        case "rule_created":
+          return getRuleCreatedEvent(d, template);
+
+        case "rule_updated":
+          return getRuleUpdatedEvent(d, template);
+
+        case "rule_deprecated":
           return {
             ...d,
             payload: [
-              ..._.flow(
-                _.path("payload"),
-                _.omit(["updated_by", "content"]),
-                _.keys,
-                _.map((field) => ({
-                  field,
-                  action:
-                    field === "description"
-                      ? "changed_without_target"
-                      : "changed",
-                  value: d.payload[field],
-                })),
-              )(d),
-              ...getContentChanges(
-                "changed",
-                content.changed,
-                ruleFieldsWithoutValue,
-              ),
-              ...getContentChanges(
-                "added",
-                content.added,
-                ruleFieldsWithoutValue,
-              ),
-              ...getContentChanges(
-                "removed",
-                content.removed,
-                ruleFieldsWithoutValue,
-              ),
+              {
+                field: _.path("payload.resource_id")(d),
+                action: "deprecated",
+                event_via,
+              },
             ],
           };
-        }
 
         default:
           return {
@@ -223,6 +527,7 @@ const getParsedEvents = createSelector(
               {
                 field: _.path("payload.implementation_key")(d),
                 action: "updated",
+                event_via,
               },
             ],
           };

package/src/styles/auditEventVia.less

@@ -0,0 +1,7 @@
+.audit-event-via {
+  color: #1e70bf;
+  display: inline-block;
+  font-weight: 700;
+  margin-right: 0em;
+  vertical-align: baseline;
+}