@genesislcap/pbc-notify-ui 1.0.64 → 14.308.0

package/src/components/foundation-notification-dashboard/notification-dashboard.utils.ts

@@ -0,0 +1,295 @@
+import { showNotification } from '@genesislcap/foundation-notifications';
+import { UUID } from '@genesislcap/foundation-utils';
+import {
+  ConditionBuilderEntity,
+  EmptyValue,
+  ExpressionType,
+  ParamSourceType,
+  ParamType,
+  RightCriteria,
+  nullAndBlankLogicalOperatorValues,
+  LogicalOperator,
+} from '../../notify.types';
+import { logger } from '../../utils';
+import { toBoolean } from '../../utils/toBoolean';
+import { ParameterBuilderEntity } from './components/templates/template-dialog/template-dialog.types';
+
+export class UUIDGenerator {
+  @UUID private static uuid: UUID;
+  static createUUID = (): string => this.uuid.createId();
+}
+
+export const isEmpty = (value) =>
+  value == null || (typeof value === 'string' && value.trim().length === 0);
+
+// #region Rules and Templates
+class ConditionUtils {
+  static transformLogicalOperator(logicalOperator) {
+    switch (logicalOperator) {
+      case LogicalOperator.NULL:
+      case LogicalOperator.BLANK:
+        return LogicalOperator.EQUALS;
+      case LogicalOperator.NOT_NULL:
+      case LogicalOperator.NOT_BLANK:
+        return LogicalOperator.NOT_EQUALS;
+      default:
+        return logicalOperator;
+    }
+  }
+
+  static buildLogicalOperator(condition) {
+    if (condition.RIGHT.TYPE === EmptyValue.NULL) {
+      return condition.OPERATION === LogicalOperator.EQUALS
+        ? LogicalOperator.NULL
+        : LogicalOperator.NOT_NULL;
+    } else if (condition.RIGHT.VALUE === EmptyValue.BLANK) {
+      return condition.OPERATION === LogicalOperator.EQUALS
+        ? LogicalOperator.BLANK
+        : LogicalOperator.NOT_BLANK;
+    } else {
+      return condition.OPERATION;
+    }
+  }
+
+  static getRightExpression(condition: ConditionBuilderEntity, parameters?) {
+    // 1. Check LOGICAL_OPERATOR for null values
+    if (
+      condition.LOGICAL_OPERATOR === LogicalOperator.NULL ||
+      condition.LOGICAL_OPERATOR === LogicalOperator.NOT_NULL
+    ) {
+      return {
+        TYPE: EmptyValue.NULL,
+      };
+    }
+
+    // 2. Check LOGICAL_OPERATOR for blank values
+    if (
+      condition.LOGICAL_OPERATOR === LogicalOperator.BLANK ||
+      condition.LOGICAL_OPERATOR === LogicalOperator.NOT_BLANK
+    ) {
+      return {
+        TYPE: 'STRING',
+        VALUE: ConditionUtils.handleNullOrBlankLogicalOperator(condition.LOGICAL_OPERATOR),
+      };
+    }
+
+    // 3. Handle by RIGHT_CRITERIA
+    switch (condition.RIGHT_CRITERIA) {
+      case 'USER_ENTRY':
+        return {
+          TYPE: 'PLACEHOLDER',
+          KEY: parameters.find((parameter) => parameter.UUID === condition.RIGHT_VALUE).PARAM_NAME,
+        };
+      case 'FIELD': // Only for Rules
+        return {
+          TYPE: 'FIELD',
+          NAME: condition.RIGHT_VALUE,
+        };
+      case 'VALUE':
+        switch (condition.LEFT_VALUE.FIELD_TYPE) {
+          case 'BOOLEAN':
+            return {
+              TYPE: 'BOOLEAN',
+              VALUE: toBoolean(condition.RIGHT_VALUE),
+            };
+          case 'STRING':
+          case 'ENUM':
+            return {
+              TYPE: 'STRING',
+              VALUE: condition.RIGHT_VALUE,
+            };
+          case 'INT':
+          case 'SHORT':
+          case 'DOUBLE':
+          case 'LONG':
+          case 'BIGDECIMAL':
+            return {
+              TYPE: 'NUMBER',
+              VALUE: condition.RIGHT_VALUE,
+            };
+          default:
+            return {
+              TYPE: 'FIELD',
+              NAME: condition.RIGHT_VALUE,
+            };
+        }
+      default:
+        logger.error(`Unexpected RIGHT_CRITERIA: ${condition.RIGHT_CRITERIA}`);
+        return {};
+    }
+  }
+
+  static handleNullOrBlankLogicalOperator(logicalOperator) {
+    switch (logicalOperator) {
+      case LogicalOperator.NULL:
+      case LogicalOperator.NOT_NULL:
+        return EmptyValue.NULL;
+      case LogicalOperator.BLANK:
+      case LogicalOperator.NOT_BLANK:
+        return EmptyValue.BLANK;
+      default:
+        logger.error(`Unexpected LogicalOperator: ${logicalOperator}`);
+        break;
+    }
+  }
+}
+
+export class DynamicRuleUtils {
+  static createEmptyCondition = (): ConditionBuilderEntity => ({
+    ID: null,
+    LEFT_VALUE: null,
+    LOGICAL_OPERATOR: LogicalOperator.EQUALS,
+    RIGHT_CRITERIA: RightCriteria.VALUE,
+    RIGHT_VALUE: null,
+  });
+
+  static createAssignment = (field: string, value: string) => ({
+    FIELD: {
+      TYPE: 'FIELD',
+      NAME: field,
+    },
+    VALUE: {
+      TYPE: 'STRING',
+      VALUE: value,
+    },
+  });
+
+  static getAssignmentValue = (assignments: any[], field: string): string =>
+    assignments.find((assignment) => assignment.FIELD.NAME === field).VALUE.VALUE;
+
+  static createConditions(conditions: ConditionBuilderEntity[], parameters?): any {
+    return conditions.map((condition) => ({
+      LEFT: {
+        TYPE: 'FIELD', // TODO: Use ParamType
+        NAME: condition.LEFT_VALUE.FIELD_NAME,
+      },
+      OPERATION: ConditionUtils.transformLogicalOperator(condition.LOGICAL_OPERATOR),
+      RIGHT: ConditionUtils.getRightExpression(condition, parameters),
+    }));
+  }
+}
+
+export class TemplateUtils {
+  static createEmptyParameter = (): ParameterBuilderEntity => ({
+    UUID: UUIDGenerator.createUUID(),
+    PARAM_NAME: null,
+    PARAM_LABEL: null,
+    PARAM_TYPE: ParamType.STRING,
+    PARAM_SOURCE_TYPE: ParamSourceType.USER_TEXT,
+    PARAM_SOURCE: null,
+  });
+
+  static getParameters(parameters) {
+    if (!parameters) {
+      return [];
+    }
+
+    return Object.keys(parameters).map((key) => ({
+      UUID: UUIDGenerator.createUUID(),
+      PARAM_NAME: parameters[key].PARAM_NAME,
+      PARAM_LABEL: parameters[key].PARAM_LABEL,
+      PARAM_TYPE: parameters[key].PARAM_TYPE,
+      PARAM_SOURCE_TYPE: parameters[key].PARAM_SOURCE_TYPE,
+      PARAM_SOURCE: parameters[key].PARAM_SOURCE,
+    }));
+  }
+
+  private static buildRightValue(logicalOperator: LogicalOperator, condition, parameters?) {
+    // Is Null or Blank
+    if (nullAndBlankLogicalOperatorValues.includes(logicalOperator)) {
+      return EmptyValue.BLANK;
+    }
+
+    // Find parameter name by key
+    if (condition.RIGHT.TYPE === ExpressionType.PLACEHOLDER) {
+      return parameters.find((parameter) => parameter.PARAM_NAME === condition.RIGHT.KEY).UUID;
+    }
+
+    // If value is null, then NAME is filled
+    return String(condition.RIGHT.VALUE ?? condition.RIGHT.NAME);
+  }
+
+  static getConditions(conditions, parameters?) {
+    return conditions.map((condition) => {
+      const logicalOperator = ConditionUtils.buildLogicalOperator(condition);
+      return {
+        ID: UUIDGenerator.createUUID(),
+        LEFT_VALUE: condition.LEFT.VALUE ?? condition.LEFT.NAME,
+        LOGICAL_OPERATOR: logicalOperator,
+        RIGHT_CRITERIA:
+          condition.RIGHT.TYPE === ExpressionType.PLACEHOLDER
+            ? RightCriteria.USER_ENTRY
+            : RightCriteria.VALUE,
+        RIGHT_VALUE: this.buildRightValue(logicalOperator, condition, parameters),
+      };
+    });
+  }
+
+  static createParameterDetails(parameters) {
+    if (!parameters || parameters.length === 0) {
+      return {};
+    }
+
+    const map = {};
+
+    parameters.forEach((parameter) => {
+      map[parameter.PARAM_NAME] = {
+        PARAM_LABEL: parameter.PARAM_LABEL,
+        PARAM_TYPE: parameter.PARAM_TYPE,
+        PARAM_SOURCE_TYPE: parameter.PARAM_SOURCE_TYPE,
+        PARAM_SOURCE: parameter.PARAM_SOURCE ?? '',
+        PARAM_OPERATOR: 'EQUALS', // TODO: Remove
+      };
+    });
+
+    return map;
+  }
+}
+
+export class RuleUtils {
+  private static buildRightValue(logicalOperator: LogicalOperator, condition) {
+    // Is Null or Blank
+    if (nullAndBlankLogicalOperatorValues.includes(logicalOperator)) {
+      return EmptyValue.BLANK;
+    }
+
+    // Get KEY
+    if (condition.RIGHT.TYPE === ExpressionType.PLACEHOLDER) {
+      return condition.RIGHT.KEY;
+    }
+
+    // If value is null, then NAME is filled
+    return String(condition.RIGHT.VALUE ?? condition.RIGHT.NAME);
+  }
+
+  static getConditions(conditions) {
+    return conditions.map((condition) => {
+      const logicalOperator = ConditionUtils.buildLogicalOperator(condition);
+      return {
+        ID: UUIDGenerator.createUUID(),
+        LEFT_VALUE: condition.LEFT.VALUE ?? condition.LEFT.NAME,
+        LOGICAL_OPERATOR: logicalOperator,
+        RIGHT_CRITERIA: condition.RIGHT.TYPE === 'FIELD' ? 'FIELD' : 'VALUE',
+        RIGHT_VALUE: this.buildRightValue(logicalOperator, condition),
+      };
+    });
+  }
+}
+// #endregion
+
+// #region Screen
+export function showNotificationError(error) {
+  showNotification(
+    {
+      title: error[0]?.CODE,
+      body: error[0]?.TEXT,
+      config: {
+        snackbar: {
+          type: 'error',
+        },
+      },
+    },
+    'rapid',
+  );
+}
+// #endregion

package/src/components/foundation-notification-dashboard/styles/condition-builder.styles.ts

@@ -0,0 +1,66 @@
+import { css } from '@genesislcap/web-core';
+
+export const ConditionBuilderStyles = css`
+  .condition-builder {
+    display: flex;
+    gap: calc(var(--design-unit) * 2px);
+    margin-bottom: calc(var(--design-unit) * 2px);
+  }
+
+  rapid-button {
+    margin: 0;
+  }
+
+  .delete {
+    margin: 0;
+    display: flex;
+    justify-content: center;
+    height: calc(var(--design-unit) * 9px);
+  }
+
+  .delete:hover {
+    background-color: color-mix(in srgb, var(--neutral-foreground-rest), transparent 89%);
+  }
+
+  rapid-text-field {
+    width: 100%;
+    margin-bottom: 0;
+  }
+
+  rapid-text-field::part(root) {
+    height: calc(var(--design-unit) * 9px);
+  }
+
+  rapid-select {
+    min-width: auto;
+  }
+
+  rapid-select.left-value::part(control) {
+    width: 250px;
+  }
+
+  rapid-select.logical-operator::part(control) {
+    width: 160px;
+  }
+
+  .logical-operator-null-and-blank {
+    width: 100%;
+  }
+
+  rapid-select.right-criteria::part(control) {
+    width: 135px;
+  }
+
+  rapid-select.right-criteria-user-entry {
+    width: 100%;
+  }
+
+  rapid-select.right-criteria-select {
+    width: 100%;
+    min-width: 0;
+  }
+
+  rapid-select::part(listbox) {
+    max-height: 160px;
+  }
+`;

package/src/components/foundation-notification-dashboard/styles/dynamic-rule.styles.ts

@@ -0,0 +1,159 @@
+import { css } from '@genesislcap/web-core';
+import { scrollbarStyles } from '../../../styles/scrollbar.styles';
+
+export const DynamicRuleManagementStyles = css`
+  .container {
+    display: flex;
+    height: 100%;
+    flex-direction: column;
+  }
+
+  .header {
+    display: flex;
+    flex-direction: row-reverse;
+  }
+
+  .grid {
+    height: 100%;
+  }
+`;
+
+// #region Dialog
+const modalWidthPx = 940;
+
+const top = css`
+  rapid-modal::part(top) {
+    padding: calc(var(--design-unit) * 4px);
+    border-bottom: calc(var(--stroke-width) * 1px) solid var(--neutral-stroke-divider-rest);
+    margin: 0;
+  }
+
+  .dialog-top {
+    font-weight: bold;
+    align-self: center;
+  }
+`;
+
+const bottom = css`
+  rapid-modal::part(bottom) {
+    padding: calc(var(--design-unit) * 4px);
+    border-top: calc(var(--stroke-width) * 1px) solid var(--neutral-stroke-divider-rest);
+    margin: 0;
+  }
+
+  .dialog-bottom {
+    display: flex;
+  }
+`;
+
+const textField = css`
+  rapid-text-field {
+    display: flex;
+    flex-direction: column;
+    gap: calc(var(--design-unit) * 2px);
+  }
+
+  rapid-text-field::part(label) {
+    margin: 0;
+    color: var(--neutral-foreground-rest);
+  }
+
+  rapid-text-field::part(label)::after {
+    content: '*';
+  }
+`;
+
+const select = css`
+  rapid-select,
+  rapid-multiselect::part(root) {
+    min-width: 0;
+  }
+
+  rapid-select::part(listbox) {
+    max-height: 160px;
+  }
+
+  rapid-multiselect {
+    max-height: 40px;
+  }
+
+  rapid-multiselect::part(filter-search) {
+    height: calc((var(--design-unit) * 9px) - 2px);
+  }
+`;
+
+export const DynamicRuleDialogStyles = css`
+  ${scrollbarStyles}
+  ${top}
+  ${bottom}
+
+  rapid-modal::part(dialog) {
+    padding: 0;
+    background: var(--neutral-layer-4);
+    border: calc(var(--stroke-width) * 1px) solid var(--neutral-stroke-divider-rest);
+  }
+
+  .dialog-content {
+    display: flex;
+    flex-direction: column;
+    width: ${String(modalWidthPx)}px;
+    max-height: 500px;
+    overflow-y: scroll;
+    gap: calc(var(--design-unit) * 3px);
+    padding: calc(var(--design-unit) * 4px);
+  }
+
+  .content-row {
+    display: flex;
+    gap: calc(var(--design-unit) * 3px);
+  }
+
+  .control {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+    gap: calc(var(--design-unit) * 2px);
+  }
+
+  .items {
+    border: calc(var(--stroke-width) * 1px) solid var(--neutral-stroke-divider-rest);
+    border-radius: calc(var(--control-corner-radius) * 1px);
+    display: flex;
+    padding: calc(var(--design-unit) * 2px);
+    flex-direction: column;
+  }
+
+  .item {
+    gap: 0;
+    flex-direction: column;
+    margin-bottom: 0;
+  }
+
+  ${textField}
+  ${select}
+
+  rapid-button {
+    margin: 0;
+  }
+
+  rapid-select {
+    min-width: 0;
+  }
+
+  rapid-select::part(listbox) {
+    max-height: 160px;
+  }
+
+  .horizontal {
+    flex-direction: row;
+  }
+
+  .destination {
+    align-self: center;
+  }
+
+  .topic {
+    min-width: revert-layer;
+  }
+`;
+// #endregion

package/src/components/foundation-notification-dashboard/styles/management.styles.ts

@@ -0,0 +1,21 @@
+import { css } from '@genesislcap/web-core';
+
+export const managementGridStyles = css`
+  :host {
+    height: 100%;
+  }
+
+  .container {
+    display: flex;
+    height: 100%;
+    flex-direction: column;
+  }
+
+  .header {
+    display: flex;
+  }
+
+  .grid {
+    height: 100%;
+  }
+`;

package/src/components/foundation-notification-dashboard/types/expression-type.ts

@@ -0,0 +1,13 @@
+export const EXPRESSION_TYPE_FIELD = 'FIELD';
+export const EXPRESSION_TYPE_NUMBER = 'NUMBER';
+export const EXPRESSION_TYPE_STRING = 'STRING';
+export const EXPRESSION_TYPE_PLACEHOLDER = 'PLACEHOLDER';
+
+export const ALL_EXPRESSION_TYPES = [
+  EXPRESSION_TYPE_FIELD,
+  EXPRESSION_TYPE_NUMBER,
+  EXPRESSION_TYPE_STRING,
+  EXPRESSION_TYPE_PLACEHOLDER,
+] as const;
+
+export type ExpressionType = (typeof ALL_EXPRESSION_TYPES)[number];

package/src/components/foundation-notification-dashboard/types/logical-operator.ts

@@ -0,0 +1,18 @@
+export const LOGICAL_OPERATOR_EQUALS = 'EQUALS';
+export const LOGICAL_OPERATOR_NOT_EQUALS = 'NOT_EQUALS';
+export const LOGICAL_OPERATOR_GREATER_THAN = 'GREATER_THAN';
+export const LOGICAL_OPERATOR_LESS_THAN = 'LESS_THAN';
+
+export const LOGICAL_OPERATOR_NULL = 'NULL';
+export const LOGICAL_OPERATOR_NOT_NULL = 'NOT_NULL';
+export const LOGICAL_OPERATOR_BLANK = 'BLANK_NULL';
+export const LOGICAL_OPERATOR_NOT_BLANK = 'NOT_BLANK';
+
+export const ALL_LOGICAL_OPERATORS = [
+  LOGICAL_OPERATOR_EQUALS,
+  LOGICAL_OPERATOR_NOT_EQUALS,
+  LOGICAL_OPERATOR_GREATER_THAN,
+  LOGICAL_OPERATOR_LESS_THAN,
+] as const;
+
+export type LogicalOperator = (typeof ALL_LOGICAL_OPERATORS)[number];

package/src/components/foundation-notification-dashboard/types/param-source-type.ts

@@ -0,0 +1,11 @@
+export const PARAM_SOURCE_TYPE_USER_TEXT = 'USER_TEXT';
+export const PARAM_SOURCE_TYPE_DEFINED_GROUP = 'DEFINED_GROUP';
+export const PARAM_SOURCE_TYPE_REQ_REP = 'REQ_REP';
+
+export const ALL_PARAM_SOURCE_TYPES = [
+  PARAM_SOURCE_TYPE_USER_TEXT,
+  PARAM_SOURCE_TYPE_DEFINED_GROUP,
+  // PARAM_SOURCE_TYPE_REQ_REP,
+] as const;
+
+export type ParamSourceType = (typeof ALL_PARAM_SOURCE_TYPES)[number];

package/src/components/foundation-notification-dashboard/types/param-type.ts

@@ -0,0 +1,13 @@
+export const PARAM_TYPE_FIELD = 'FIELD';
+export const PARAM_TYPE_STRING = 'STRING';
+export const PARAM_TYPE_BOOLEAN = 'BOOLEAN';
+export const PARAM_TYPE_NUMBER = 'NUMBER';
+
+export const ALL_PARAM_TYPES = [
+  // PARAM_TYPE_FIELD,
+  PARAM_TYPE_STRING,
+  // PARAM_TYPE_BOOLEAN,
+  PARAM_TYPE_NUMBER,
+] as const;
+
+export type ParamType = (typeof ALL_PARAM_TYPES)[number];

package/src/components/foundation-notification-dashboard/types/right-criteria.ts

@@ -0,0 +1,6 @@
+export const RIGHT_CRITERIA_VALUE = 'VALUE';
+export const RIGHT_CRITERIA_USER_ENTRY = 'USER_ENTRY';
+
+export const ALL_RIGHT_CRITERIAS = [RIGHT_CRITERIA_VALUE, RIGHT_CRITERIA_USER_ENTRY] as const;
+
+export type RightCriteria = (typeof ALL_RIGHT_CRITERIAS)[number];

package/src/components/foundation-notification-dashboard/types/rule-execution-strategy.ts

@@ -0,0 +1,6 @@
+export const RULE_EXECUTION_UNLIMITED = 'UNLIMITED';
+export const RULE_EXECUTION = 'ONCE_ONLY';
+
+export const ALL_RULE_EXECUTION_STRATEGIES = [RULE_EXECUTION_UNLIMITED, RULE_EXECUTION] as const;
+
+export type RuleExecutionStrategy = (typeof ALL_RULE_EXECUTION_STRATEGIES)[number];

package/src/components/foundation-notification-dashboard/types/severity.ts

@@ -0,0 +1,13 @@
+export const SEVERITY_INFORMATION = 'INFORMATION';
+export const SEVERITY_CRITICAL = 'CRITICAL';
+export const SEVERITY_SERIOUS = 'SERIOUS';
+export const SEVERITY_WARNING = 'WARNING';
+
+export const ALL_SEVERITIES = [
+  { type: SEVERITY_INFORMATION, text: 'Information' },
+  { type: SEVERITY_WARNING, text: 'Warning' },
+  { type: SEVERITY_SERIOUS, text: 'Serious' },
+  { type: SEVERITY_CRITICAL, text: 'Critical' },
+] as const;
+
+export type Severity = (typeof ALL_SEVERITIES)[number];

package/src/globals.d.ts

@@ -0,0 +1,7 @@
+declare global {
+  const GENX_SANDBOX_API_HOST: string;
+  const GENX_SANDBOX_DEFAULT_USER: string;
+  const GENX_SANDBOX_DEFAULT_PASSWORD: string;
+}
+
+export {};

package/src/index.federated.ts

@@ -0,0 +1 @@
+import('./index');

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './components/foundation-inbox/inbox';
+export * from './components/foundation-inbox/components/foundation-inbox-flyout/foundation-inbox-flyout';
+export * from './components/foundation-inbox/components/foundation-inbox-counter/foundation-inbox-counter';
+export * from './components/foundation-notification-dashboard';