@genesislcap/pbc-notify-ui 1.0.64 → 14.309.0

package/src/components/foundation-notification-dashboard/components/routes/tabs/email-user-route-management.ts

@@ -0,0 +1,68 @@
+import { customElement, GenesisElement, html } from '@genesislcap/web-core';
+import { managementGridStyles } from '../../../styles/management.styles';
+
+const EMAIL_USER_ROUTE_COLUMNS = [
+  {
+    field: 'NOTIFY_ROUTE_ID',
+    headerName: 'Notify Route Id',
+    flex: 1,
+  },
+  {
+    field: 'TOPIC_MATCH',
+    headerName: 'Topic Match',
+    flex: 1,
+  },
+  {
+    field: 'GATEWAY_ID',
+    headerName: 'Gateway Id',
+    flex: 1,
+  },
+  {
+    field: 'ROUTE_ENABLED',
+    headerName: 'Route Enabled',
+    flex: 1,
+  },
+  {
+    field: 'ENTITY_ID',
+    headerName: 'Entity Id',
+    flex: 1,
+  },
+  {
+    field: 'ENTITY_ID_TYPE',
+    headerName: 'Entity Id Type',
+    flex: 1,
+  },
+  {
+    field: 'RIGHT_CODE',
+    headerName: 'Right Code',
+    flex: 1,
+  },
+  {
+    field: 'AUTH_CACHE_NAME',
+    headerName: 'Auth Cache Name',
+    flex: 1,
+  },
+  {
+    field: 'EXCLUDE_SENDER',
+    headerName: 'Exclude Sender',
+    flex: 1,
+  },
+];
+
+@customElement({
+  name: 'email-user-route-management',
+  template: html<EmailUserRouteManagement>`
+    <div class="grid">
+      <entity-management
+        design-system-prefix="rapid"
+        resourceName="ALL_EMAIL_USER_ROUTES"
+        createEvent="EVENT_EMAIL_USER_ROUTE_CREATE"
+        updateEvent="EVENT_EMAIL_USER_ROUTE_UPDATE"
+        deleteEvent="EVENT_EMAIL_USER_ROUTE_DELETE"
+        :columns=${() => [...EMAIL_USER_ROUTE_COLUMNS]}
+      ></entity-management>
+    </div>
+  `,
+  styles: managementGridStyles,
+})
+export class EmailUserRouteManagement extends GenesisElement {}

package/src/components/foundation-notification-dashboard/components/routes/tabs/log-route-management.ts

@@ -0,0 +1,43 @@
+import { customElement, GenesisElement, html } from '@genesislcap/web-core';
+import { managementGridStyles } from '../../../styles/management.styles';
+
+const LOG_ROUTE_MANAGEMENT_COLUMNS = [
+  {
+    field: 'NOTIFY_ROUTE_ID',
+    headerName: 'Notify Route Id',
+    flex: 1,
+  },
+  {
+    field: 'TOPIC_MATCH',
+    headerName: 'Topic Match',
+    flex: 1,
+  },
+  {
+    field: 'GATEWAY_ID',
+    headerName: 'Gateway Id',
+    flex: 1,
+  },
+  {
+    field: 'ROUTE_ENABLED',
+    headerName: 'Route Enabled',
+    flex: 1,
+  },
+];
+
+@customElement({
+  name: 'log-route-management',
+  template: html<LogRouteManagement>`
+    <div class="grid">
+      <entity-management
+        design-system-prefix="rapid"
+        resourceName="ALL_LOG_ROUTES"
+        createEvent="EVENT_LOG_ROUTE_CREATE"
+        updateEvent="EVENT_LOG_ROUTE_UPDATE"
+        deleteEvent="EVENT_LOG_ROUTE_DELETE"
+        :columns=${() => [...LOG_ROUTE_MANAGEMENT_COLUMNS]}
+      ></entity-management>
+    </div>
+  `,
+  styles: managementGridStyles,
+})
+export class LogRouteManagement extends GenesisElement {}

package/src/components/foundation-notification-dashboard/components/routes/tabs/ms-teams-route-management.ts

@@ -0,0 +1,48 @@
+import { customElement, GenesisElement, html } from '@genesislcap/web-core';
+import { managementGridStyles } from '../../../styles/management.styles';
+
+const MS_TEAMS_ROUTE_MANAGEMENT_COLUMNS = [
+  {
+    field: 'NOTIFY_ROUTE_ID',
+    headerName: 'Notify Route Id',
+    flex: 1,
+  },
+  {
+    field: 'TOPIC_MATCH',
+    headerName: 'Topic Match',
+    flex: 1,
+  },
+  {
+    field: 'GATEWAY_ID',
+    headerName: 'Gateway Id',
+    flex: 1,
+  },
+  {
+    field: 'ROUTE_ENABLED',
+    headerName: 'Route Enabled',
+    flex: 1,
+  },
+  {
+    field: 'URL',
+    headerName: 'Url',
+    flex: 1,
+  },
+];
+
+@customElement({
+  name: 'ms-teams-route-management',
+  template: html<MSTeamsRouteManagement>`
+    <div class="grid">
+      <entity-management
+        design-system-prefix="rapid"
+        resourceName="ALL_MS_TEAMS_ROUTES"
+        createEvent="EVENT_MS_TEAMS_ROUTE_CREATE"
+        updateEvent="EVENT_MS_TEAMS_ROUTE_UPDATE"
+        deleteEvent="EVENT_MS_TEAMS_ROUTE_DELETE"
+        :columns=${() => [...MS_TEAMS_ROUTE_MANAGEMENT_COLUMNS]}
+      ></entity-management>
+    </div>
+  `,
+  styles: managementGridStyles,
+})
+export class MSTeamsRouteManagement extends GenesisElement {}

package/src/components/foundation-notification-dashboard/components/routes/tabs/screen-route-management.ts

@@ -0,0 +1,73 @@
+import { UiSchema } from '@genesislcap/foundation-forms';
+import { customElement, GenesisElement, html } from '@genesislcap/web-core';
+import { managementGridStyles } from '../../../styles/management.styles';
+
+const SCREEN_ROUTE_MANAGEMENT_COLUMNS = [
+  {
+    field: 'NOTIFY_ROUTE_ID',
+    headerName: 'Notify Route Id',
+    flex: 1,
+  },
+  {
+    field: 'TOPIC_MATCH',
+    headerName: 'Topic Match',
+    flex: 1,
+  },
+  {
+    field: 'GATEWAY_ID',
+    headerName: 'Gateway Id',
+    flex: 1,
+  },
+  {
+    field: 'ROUTE_ENABLED',
+    headerName: 'Route Enabled',
+    flex: 1,
+  },
+  {
+    field: 'ENTITY_ID',
+    headerName: 'Entity Id',
+    flex: 1,
+  },
+  {
+    field: 'ENTITY_ID_TYPE',
+    headerName: 'Entity Id Type',
+    flex: 1,
+  },
+  {
+    field: 'EXCLUDE_SENDER',
+    headerName: 'Exclude Sender',
+    flex: 1,
+  },
+];
+
+const SCREEN_ROUTE_MANAGEMENT_UI_SCHEMA: UiSchema = {
+  type: 'VerticalLayout',
+  elements: [
+    { type: 'Control', scope: '#/properties/ENTITY_ID', label: 'ENTITY ID' },
+    { type: 'Control', scope: '#/properties/ENTITY_ID_TYPE', label: 'ENTITY ID TYPE' },
+    { type: 'Control', scope: '#/properties/EXCLUDE_SENDER', label: 'EXCLUDE SENDER' },
+    { type: 'Control', scope: '#/properties/GATEWAY_ID', label: 'GATEWAY ID' },
+    { type: 'Control', scope: '#/properties/ROUTE_ENABLED', label: 'ROUTE ENABLED' },
+    { type: 'Control', scope: '#/properties/TOPIC_MATCH', label: 'TOPIC MATCH' },
+  ],
+};
+
+@customElement({
+  name: 'screen-route-management',
+  template: html<ScreenRouteManagement>`
+    <div class="grid">
+      <entity-management
+        design-system-prefix="rapid"
+        resourceName="ALL_SCREEN_ROUTES"
+        createEvent="EVENT_SCREEN_NOTIFY_ROUTE_CREATE"
+        updateEvent="EVENT_SCREEN_NOTIFY_ROUTE_UPDATE"
+        deleteEvent="EVENT_SCREEN_NOTIFY_ROUTE_DELETE"
+        :columns=${() => [...SCREEN_ROUTE_MANAGEMENT_COLUMNS]}
+        :createFormUiSchema=${(x) => SCREEN_ROUTE_MANAGEMENT_UI_SCHEMA}
+        :updateFormUiSchema=${(x) => SCREEN_ROUTE_MANAGEMENT_UI_SCHEMA}
+      ></entity-management>
+    </div>
+  `,
+  styles: managementGridStyles,
+})
+export class ScreenRouteManagement extends GenesisElement {}

package/src/components/foundation-notification-dashboard/components/rules/columns.ts

@@ -0,0 +1,48 @@
+import { buttonCellRenderer } from '@genesislcap/foundation-entity-management';
+import { deleteIcon, editIcon } from '../../../../utils';
+import type { RuleManagement } from './rule-management';
+
+export const RULE_MANAGEMENT_COLUMNS = (context: RuleManagement) => [
+  {
+    field: 'NAME',
+    headerName: 'Name',
+    flex: 1,
+  },
+  {
+    field: 'DESCRIPTION',
+    headerName: 'Description',
+    flex: 1,
+  },
+  {
+    field: 'USER_NAME',
+    headerName: 'Username',
+    flex: 1,
+  },
+  {
+    field: 'RULE_TABLE',
+    headerName: 'Table',
+    flex: 1,
+  },
+  {
+    field: 'RULE_STATUS',
+    headerName: 'Status',
+    flex: 1,
+  },
+  {
+    field: 'RULE_EXPRESSION',
+    headerName: 'Expression',
+    flex: 1,
+  },
+  {
+    field: 'RESULT_EXPRESSION',
+    headerName: 'Result',
+    flex: 1,
+  },
+  {
+    field: 'RULE_EXECUTION_STRATEGY',
+    headerName: 'Execution Strategy',
+    flex: 1,
+  },
+  buttonCellRenderer('Edit', (e) => context.editRule(e), editIcon),
+  buttonCellRenderer('Delete', (e) => context.deleteRule(e), deleteIcon),
+];

package/src/components/foundation-notification-dashboard/components/rules/rule-dialog/rule-condition-builder/rule-condition-builder.template.ts

@@ -0,0 +1,139 @@
+import { FieldTypeEnum } from '@genesislcap/foundation-comms';
+import { sync } from '@genesislcap/foundation-utils';
+import { classNames, html, repeat, when, whenElse } from '@genesislcap/web-core';
+import { LogicalOperator, nullAndBlankLogicalOperatorValues } from '../../../../../../notify.types';
+import type { RuleConditionBuilder } from './rule-condition-builder';
+import { RightCriteria } from './rule-condition-builder.types';
+
+export const RuleConditionBuilderTemplate = html<RuleConditionBuilder>`
+  <div class="condition-builder">
+    <rapid-select
+      :value=${sync((x) => x.leftValue)}
+      :initialValue=${sync((x) => x.leftValue)}
+      title=${(x) => (x.leftValue ? JSON.parse(x.leftValue).FIELD_NAME : '')}
+      class="left-value"
+    >
+      ${repeat(
+        (x) => x.getAllFields(),
+        html`
+          <rapid-option value=${(x) => JSON.stringify(x)} title=${(x) => x.FIELD_NAME}>
+            ${(x) => x.FIELD_NAME}
+          </rapid-option>
+        `,
+      )}
+    </rapid-select>
+
+    <rapid-select
+      class="logical-operator${(x) =>
+        classNames([
+          '-null-and-blank',
+          nullAndBlankLogicalOperatorValues.includes(LogicalOperator[x.logicalOperator]),
+        ])}"
+      :value=${sync((x) => x.logicalOperator)}
+      title=${(x) => x.logicalOperator}
+    >
+      ${repeat(
+        (x) => x.getLogicalOperators(),
+        html`
+          <rapid-option value=${(x) => x.operator} title=${(x) => x}>
+            ${(x) => x.label}
+          </rapid-option>
+        `,
+      )}
+    </rapid-select>
+
+    ${when(
+      (x) => !nullAndBlankLogicalOperatorValues.includes(LogicalOperator[x.logicalOperator]),
+      html`
+        <rapid-select
+          class="right-criteria"
+          :value=${sync((x) => x.rightCriteria)}
+          title=${(x) => x.rightCriteria}
+        >
+          ${repeat(
+            (x) => x.getRightCriteria(),
+            html`
+              <rapid-option value=${(x) => x} title=${(x) => x}>${(x) => x}</rapid-option>
+            `,
+          )}
+        </rapid-select>
+
+        ${when(
+          (x) => x.rightCriteria === RightCriteria.VALUE,
+          html`
+            ${whenElse(
+              (x) => JSON.parse(x.leftValue ?? '{}').FIELD_TYPE === FieldTypeEnum.BOOLEAN,
+              html`
+                <rapid-select class="right-criteria-select" :value=${sync((x) => x.rightValueText)}>
+                  <rapid-option value="true">true</rapid-option>
+                  <rapid-option value="false">false</rapid-option>
+                </rapid-select>
+              `,
+              html`
+                ${whenElse(
+                  (x) => JSON.parse(x.leftValue ?? '{}').FIELD_TYPE === FieldTypeEnum.DATE,
+                  html`
+                    <rapid-text-field
+                      class="right-criteria-text"
+                      :value=${sync((x) => x.rightValueText)}
+                      type="date"
+                    ></rapid-text-field>
+                  `,
+                  html`
+                    ${whenElse(
+                      (x) => JSON.parse(x.leftValue ?? '{}').FIELD_TYPE === FieldTypeEnum.DATETIME,
+                      html`
+                        <rapid-text-field
+                          class="right-criteria-text"
+                          :value=${sync((x) => x.rightValueText)}
+                          type="datetime-local"
+                        ></rapid-text-field>
+                      `,
+                      html`
+                        <rapid-text-field
+                          class="right-criteria-text"
+                          :value=${sync((x) => x.rightValueText)}
+                          placeholder="Value"
+                          autocomplete="off"
+                        ></rapid-text-field>
+                      `,
+                    )}
+                  `,
+                )}
+              `,
+            )}
+          `,
+        )}
+        ${when(
+          (x) => x.rightCriteria === RightCriteria.FIELD,
+          html`
+            <rapid-select
+              class="right-criteria-select"
+              :value=${sync((x) => x.rightValueSelect)}
+              title=${(x) => x.rightValueSelect}
+            >
+              ${repeat(
+                (x) => x.getApplicableFields(),
+                html`
+                  <rapid-option value=${(x) => x.FIELD_NAME} title=${(x) => x.FIELD_NAME}>
+                    ${(x) => x.FIELD_NAME}
+                  </rapid-option>
+                `,
+              )}
+            </rapid-select>
+          `,
+        )}
+      `,
+    )}
+
+    <rapid-button appearance="icon" class="delete" @click=${(x) => x.deleteCondition()}>
+      <rapid-icon
+        style="opacity: 0.5"
+        variant="regular"
+        name="trash-alt"
+        size="lg"
+        part="icon"
+      ></rapid-icon>
+    </rapid-button>
+  </div>
+`;

package/src/components/foundation-notification-dashboard/components/rules/rule-dialog/rule-condition-builder/rule-condition-builder.ts

@@ -0,0 +1,255 @@
+import { FieldTypeEnum } from '@genesislcap/foundation-comms';
+import { customElement, GenesisElement, observable } from '@genesislcap/web-core';
+import dayjs from 'dayjs';
+import {
+  ConditionBuilderEntity,
+  DateLogicalOperators,
+  LogicalOperator,
+  LogicalOperators,
+  nullAndBlankLogicalOperatorValues,
+} from '../../../../../../notify.types';
+import { Field } from '../../../../../../services/system.service';
+import { logger } from '../../../../../../utils';
+import { ConditionBuilderStyles } from '../../../../styles/condition-builder.styles';
+import { RuleConditionBuilderTemplate } from './rule-condition-builder.template';
+import { RightCriteria } from './rule-condition-builder.types';
+
+@customElement({
+  name: 'rule-condition-builder',
+  template: RuleConditionBuilderTemplate,
+  styles: ConditionBuilderStyles,
+})
+export class RuleConditionBuilder extends GenesisElement {
+  @observable condition: ConditionBuilderEntity;
+  @observable fields: Field[] = [];
+
+  @observable leftValue: string = null;
+  @observable leftValueItems: Array<any> = [];
+
+  @observable logicalOperator: string = null;
+
+  @observable rightCriteria: string = RightCriteria.VALUE;
+  @observable rightValueText: string = null;
+  @observable rightValueSelect: string = null;
+
+  deleteCondition() {
+    this.$emit('delete', this.condition as ConditionBuilderEntity);
+  }
+
+  async conditionChanged() {
+    if (this.fields) {
+      this.leftValueItems = this.fields;
+    }
+
+    const rightValue = this.condition.RIGHT_VALUE;
+    this.assignLeftValue();
+    this.logicalOperator = this.condition.LOGICAL_OPERATOR;
+    this.rightCriteria = this.condition.RIGHT_CRITERIA;
+    this.condition.RIGHT_VALUE = rightValue;
+    this.assignRightValue();
+
+    this.$emit('edit', this.condition as ConditionBuilderEntity);
+  }
+
+  fieldsChanged() {
+    if (!Array.isArray(this.fields) || !this.fields.length) {
+      return;
+    }
+
+    this.leftValueItems = this.fields;
+    this.leftValue = JSON.stringify(this.leftValueItems[0]);
+  }
+
+  private assignLeftValue() {
+    if (!this.condition.LEFT_VALUE) {
+      // Add (fresh new; assign the 1st element)
+      this.leftValue = JSON.stringify(this.leftValueItems[0]);
+    } else if (typeof this.condition.LEFT_VALUE !== 'string') {
+      // Add (value changed)
+      this.leftValue = JSON.stringify(this.condition.LEFT_VALUE);
+    } else {
+      // Edit
+      this.leftValue = JSON.stringify(
+        this.leftValueItems.find((item) => item.FIELD_NAME === this.condition.LEFT_VALUE),
+      );
+    }
+
+    this.condition.LEFT_VALUE = JSON.parse(this.leftValue ?? '{}');
+  }
+
+  assignRightValue() {
+    if (this.condition.RIGHT_CRITERIA === RightCriteria.VALUE) {
+      switch (this.condition.LEFT_VALUE.FIELD_TYPE) {
+        case 'DATE':
+          this.rightValueText = this.convertLongForDatePicker(Number(this.condition.RIGHT_VALUE));
+          break;
+        case 'DATETIME':
+          this.rightValueText = this.convertLongForDatePicker(
+            Number(this.condition.RIGHT_VALUE),
+            true,
+          );
+          break;
+        default:
+          this.rightValueText = this.condition.RIGHT_VALUE;
+      }
+      return;
+    } else if (this.condition.RIGHT_CRITERIA === RightCriteria.FIELD) {
+      this.rightValueSelect = this.condition.RIGHT_VALUE;
+      return;
+    }
+
+    this.rightValueSelect = null;
+  }
+
+  getRightCriteria(): Array<any> {
+    return Object.values(RightCriteria);
+  }
+
+  getLogicalOperators(): Array<any> {
+    const leftFieldType = JSON.parse(this.leftValue ?? '{}').FIELD_TYPE;
+
+    if (leftFieldType === FieldTypeEnum.DATE || leftFieldType === FieldTypeEnum.DATETIME) {
+      return Object.values(DateLogicalOperators);
+    } else {
+      return LogicalOperators;
+    }
+  }
+
+  leftValueChanged() {
+    if (!this.condition) {
+      return;
+    }
+
+    this.getLogicalOperators();
+
+    this.condition.LEFT_VALUE = JSON.parse(this.leftValue ?? '{}');
+
+    if (this.condition.LEFT_VALUE.FIELD_TYPE === FieldTypeEnum.BOOLEAN) {
+      this.rightValueText = 'true';
+    } else {
+      this.clearRightValueText();
+    }
+
+    this.$emit('edit', this.condition as ConditionBuilderEntity);
+  }
+
+  logicalOperatorChanged() {
+    if (!this.condition) {
+      return;
+    }
+
+    if (nullAndBlankLogicalOperatorValues.includes(LogicalOperator[this.logicalOperator])) {
+      this.rightCriteria = RightCriteria.VALUE;
+      this.clearRightValueText();
+    }
+
+    this.condition.LOGICAL_OPERATOR = this.logicalOperator;
+    this.$emit('edit', this.condition as ConditionBuilderEntity);
+  }
+
+  rightCriteriaChanged() {
+    if (!this.condition) {
+      return;
+    }
+
+    this.condition.RIGHT_CRITERIA = this.rightCriteria;
+
+    switch (this.rightCriteria) {
+      case RightCriteria.VALUE:
+        if (this.condition.LEFT_VALUE.FIELD_TYPE === FieldTypeEnum.BOOLEAN) {
+          this.rightValueText = 'true';
+        } else {
+          this.clearRightValueText();
+        }
+        break;
+      case RightCriteria.FIELD:
+        this.clearRightValueSelect();
+        break;
+      default:
+        logger.error(`Unknown RightCriteria: ${this.rightCriteria}`);
+        break;
+    }
+
+    this.$emit('edit', this.condition as ConditionBuilderEntity);
+  }
+
+  private clearRightValueText() {
+    this.rightValueText = '';
+  }
+
+  private clearRightValueSelect() {
+    this.rightValueSelect = this.fields[0].FIELD_NAME;
+  }
+
+  rightValueTextChanged() {
+    if (!this.condition) {
+      return;
+    }
+
+    switch (this.condition.LEFT_VALUE.FIELD_TYPE) {
+      case FieldTypeEnum.DATETIME:
+      case FieldTypeEnum.DATE:
+        this.condition.RIGHT_VALUE = `${this.convertDateTime(this.rightValueText)}`;
+        break;
+      default:
+        this.condition.RIGHT_VALUE = this.rightValueText;
+        break;
+    }
+
+    this.$emit('edit', this.condition as ConditionBuilderEntity);
+  }
+
+  rightValueSelectChanged() {
+    if (!this.condition) {
+      return;
+    }
+
+    this.condition.RIGHT_VALUE = this.rightValueSelect;
+    this.$emit('edit', this.condition as ConditionBuilderEntity);
+  }
+
+  convertDateTime(dateTimeStr: string) {
+    if (!dateTimeStr || dateTimeStr == '') return;
+    const unixTimestampMillis = dayjs.utc(dateTimeStr).valueOf();
+    return unixTimestampMillis;
+  }
+
+  convertLongForDatePicker(value: number, time: boolean = false) {
+    return time ? dayjs(value).format('YYYY-MM-DDTHH:mm') : dayjs(value).format('YYYY-MM-DD');
+  }
+
+  getAllFields() {
+    return this.fields.filter((field) => field.FIELD_NAME != 'TIMESTAMP');
+  }
+
+  getApplicableFields() {
+    const leftFieldType = JSON.parse(this.leftValue ?? '{}').FIELD_TYPE;
+    const leftFieldName = JSON.parse(this.leftValue ?? '{}').FIELD_NAME;
+
+    // Prevent comparing the field to itself
+    const applicableFields = this.getAllFields().filter(
+      (field) => field.FIELD_NAME != leftFieldName,
+    );
+
+    switch (leftFieldType) {
+      case FieldTypeEnum.DATE:
+      case FieldTypeEnum.DATETIME:
+        return applicableFields.filter(
+          (field) =>
+            field.FIELD_TYPE === FieldTypeEnum.DATE || field.FIELD_TYPE === FieldTypeEnum.DATETIME,
+        );
+      case FieldTypeEnum.BOOLEAN:
+        return applicableFields.filter((field) => field.FIELD_TYPE === FieldTypeEnum.BOOLEAN);
+      case FieldTypeEnum.NUMBER:
+        return applicableFields.filter((field) => field.FIELD_TYPE === FieldTypeEnum.NUMBER);
+      default:
+        return applicableFields.filter(
+          (field) =>
+            field.FIELD_TYPE !== FieldTypeEnum.DATE &&
+            field.FIELD_TYPE !== FieldTypeEnum.DATETIME &&
+            field.FIELD_TYPE !== FieldTypeEnum.BOOLEAN &&
+            field.FIELD_TYPE !== FieldTypeEnum.NUMBER,
+        );
+    }
+  }
+}

package/src/components/foundation-notification-dashboard/components/rules/rule-dialog/rule-condition-builder/rule-condition-builder.types.ts

@@ -0,0 +1,4 @@
+export enum RightCriteria {
+  VALUE = 'VALUE',
+  FIELD = 'FIELD',
+}