@genesislcap/pbc-notify-ui 1.0.64 → 14.308.0

package/src/notify.types.ts

@@ -0,0 +1,143 @@
+// #region Enums
+export enum LogicalOperator {
+  EQUALS = 'EQUALS',
+  NOT_EQUALS = 'NOT_EQUALS',
+  GREATER_THAN = 'GREATER_THAN',
+  LESS_THAN = 'LESS_THAN',
+  NULL = 'NULL',
+  NOT_NULL = 'NOT_NULL',
+  BLANK = 'BLANK',
+  NOT_BLANK = 'NOT_BLANK',
+}
+
+export const LogicalOperators = [
+  {
+    label: 'Equals',
+    operator: 'EQUALS',
+  },
+  {
+    label: 'Not Equals',
+    operator: 'NOT_EQUALS',
+  },
+  {
+    label: 'Greater Than',
+    operator: 'GREATER_THAN',
+  },
+  {
+    label: 'Less Than',
+    operator: 'LESS_THAN',
+  },
+  {
+    label: 'Null',
+    operator: 'NULL',
+  },
+  {
+    label: 'Not Null',
+    operator: 'NOT_NULL',
+  },
+  {
+    label: 'Blank',
+    operator: 'BLANK',
+  },
+  {
+    label: 'Not Blank',
+    operator: 'NOT_BLANK',
+  },
+];
+
+export const DateLogicalOperators = [
+  {
+    label: 'Equals',
+    operator: 'EQUALS',
+  },
+  {
+    label: 'Not Equals',
+    operator: 'NOT_EQUALS',
+  },
+  {
+    label: 'After',
+    operator: 'GREATER_THAN',
+  },
+  {
+    label: 'On or After',
+    operator: 'GREATER_THAN_OR_EQUAL',
+  },
+  {
+    label: 'Before',
+    operator: 'LESS_THAN',
+  },
+  {
+    label: 'On or Before',
+    operator: 'LESS_THAN_OR_EQUAL',
+  },
+];
+
+export const nullAndBlankLogicalOperatorValues = [
+  LogicalOperator.NULL,
+  LogicalOperator.NOT_NULL,
+  LogicalOperator.BLANK,
+  LogicalOperator.NOT_BLANK,
+];
+
+export enum RightCriteria {
+  VALUE = 'VALUE',
+  USER_ENTRY = 'USER_ENTRY',
+}
+
+export enum ParamType {
+  // FIELD = 'FIELD',
+  STRING = 'STRING',
+  // BOOLEAN = 'BOOLEAN',
+  NUMBER = 'NUMBER',
+}
+
+export enum ParamSourceType {
+  USER_TEXT = 'USER_TEXT',
+  DEFINED_GROUP = 'DEFINED_GROUP',
+  REQ_REP = 'REQ_REP',
+}
+
+export enum Severity {
+  INFORMATION = 'INFORMATION',
+  CRITICAL = 'CRITICAL',
+  SERIOUS = 'SERIOUS',
+  WARNING = 'WARNING',
+}
+
+export enum ExpressionType {
+  FIELD = 'FIELD',
+  NUMBER = 'NUMBER',
+  STRING = 'STRING',
+  PLACEHOLDER = 'PLACEHOLDER',
+}
+
+export enum Assignment {
+  HEADER = 'HEADER',
+  BODY = 'BODY',
+  NOTIFY_SEVERITY = 'NOTIFY_SEVERITY',
+  TOPIC = 'TOPIC',
+}
+
+export enum UpdateType {
+  INSERT = 'INSERT',
+  MODIFY = 'MODIFY',
+  DELETE = 'DELETE',
+}
+
+export const defaultUpdateType = [UpdateType.INSERT];
+
+export enum EmptyValue {
+  BLANK = '',
+  NULL = 'NULL',
+}
+// #endregion
+
+// #region Types
+export type ConditionBuilderEntity = {
+  ID: string;
+  LEFT_VALUE: any;
+  LOGICAL_OPERATOR: string;
+  RIGHT_CRITERIA: string;
+  RIGHT_VALUE: string;
+};
+// #endregion

package/src/sandbox.ts

@@ -0,0 +1,83 @@
+import { Auth, AuthType, Connect } from '@genesislcap/foundation-comms';
+import { css, customElement, GenesisElement, html, observable, when } from '@genesislcap/web-core';
+
+@customElement({
+  name: 'notify-sandbox',
+  template: html`
+    ${when(
+      (x) => x.ready,
+      html`
+        <rapid-design-system-provider>
+          <div
+            style="width:100%; display:flex; justify-content:flex-end; margin-top:10px; margin-bottom:10px;"
+          >
+            <rapid-button @click=${(x) => x.openFlyout()}>
+              Open right positioned flyout
+            </rapid-button>
+            <rapid-flyout
+              :closed="${(x) => !x.rightFlyoutActive}"
+              @closed=${(x) => (x.rightFlyoutActive = false)}
+            >
+              <div slot="title">Alerts Center</div>
+              <foundation-inbox></foundation-inbox>
+            </rapid-flyout>
+          </div>
+          <rapid-tabs>
+            <rapid-tab slot="dashboard">Dashboard</rapid-tab>
+            <rapid-tab slot="inbox">Inbox</rapid-tab>
+            <rapid-tab slot="counter">Counter</rapid-tab>
+            <rapid-tab-panel>
+              <foundation-notification-dashboard></foundation-notification-dashboard>
+            </rapid-tab-panel>
+            <rapid-tab-panel>
+              <foundation-inbox></foundation-inbox>
+            </rapid-tab-panel>
+            <rapid-tab-panel>
+              <foundation-inbox-counter></foundation-inbox-counter>
+            </rapid-tab-panel>
+          </rapid-tabs>
+        </rapid-design-system-provider>
+      `,
+    )}
+  `,
+  styles: css`
+    rapid-flyout > foundation-inbox {
+      height: 100vh;
+    }
+    rapid-flyout::part(flyout) {
+      min-width: 800px;
+    }
+  `,
+})
+export class ReconciliationSandbox extends GenesisElement {
+  @Connect connect!: Connect;
+  @Auth auth!: Auth;
+  @observable ready = false;
+  @observable rightFlyoutActive = false;
+
+  async connectedCallback() {
+    super.connectedCallback();
+
+    console.log('.env:', {
+      GENX_SANDBOX_DEFAULT_USER,
+      GENX_SANDBOX_DEFAULT_PASSWORD,
+      GENX_SANDBOX_API_HOST,
+    });
+
+    await this.connect.connect(GENX_SANDBOX_API_HOST);
+
+    await this.auth.login({
+      username: GENX_SANDBOX_DEFAULT_USER,
+      password: GENX_SANDBOX_DEFAULT_PASSWORD,
+      type: AuthType.BASIC,
+    });
+
+    this.auth.isLoggedIn$.subscribe((isLoggedIn) => {
+      this.ready = isLoggedIn;
+    });
+  }
+
+  openFlyout() {
+    this.rightFlyoutActive = true;
+  }
+}

package/src/services/alert.service.ts

@@ -0,0 +1,36 @@
+import { Connect, Message, SocketObservable } from '@genesislcap/foundation-comms';
+import { DI } from '@genesislcap/web-core';
+
+export interface AlertService {
+  getAlerts(): SocketObservable<Message<any>>;
+  dismissNotifyAlert(alertId: string);
+  dismissAllNotifyAlerts();
+}
+
+class AlertServiceImpl implements AlertService {
+  @Connect private connect: Connect;
+
+  public getAlerts(): SocketObservable<Message<any>> {
+    return this.connect.stream(
+      'ALL_NOTIFY_ALERT_RECORDS',
+      (streamMessage: Message) => {
+        () => {};
+      },
+      (x) => {},
+    );
+  }
+
+  public async dismissNotifyAlert(alertId: string) {
+    return this.connect.commitEvent('EVENT_DISMISS_NOTIFY_ALERT', {
+      DETAILS: {
+        ALERT_ID: alertId,
+      },
+    });
+  }
+
+  public async dismissAllNotifyAlerts() {
+    return this.connect.commitEvent('EVENT_DISMISS_ALL_NOTIFY_ALERT', { DETAILS: {} });
+  }
+}
+
+export const AlertService = DI.createInterface<AlertService>((x) => x.singleton(AlertServiceImpl));

package/src/services/inbox.service.ts

@@ -0,0 +1,85 @@
+import { Auth, Connect, SocketObservable, SocketSubscription } from '@genesislcap/foundation-comms';
+import { DI } from '@genesislcap/web-core';
+import { logger, updateArray } from '../utils';
+
+export interface FoundationInboxServiceStore {
+  items: Array<any>;
+}
+
+export type SubscribeCallback = ({ store }: { store: FoundationInboxServiceStore }) => any;
+
+export type Subscription = {
+  callback: SubscribeCallback;
+  socketSubscription: SocketSubscription;
+};
+
+export interface FoundationInboxService {
+  subscribe(callback: SubscribeCallback, reverse: boolean, criteriaMatch: string): void;
+  unsubscribe(callback: SubscribeCallback): void;
+}
+
+class FoundationInboxServiceImpl implements FoundationInboxService {
+  @Connect private connect: Connect;
+  @Auth private auth: Auth;
+  private stream: SocketObservable<any> | null;
+  private subscriptions: Subscription[] = [];
+  public store: FoundationInboxServiceStore = {
+    items: [],
+  };
+
+  private getStream(reverse: boolean, criteriaMatch: string): SocketObservable<any> {
+    return this.connect.stream(
+      'ALL_NOTIFY_ALERT_RECORDS',
+      (result) => {
+        if (result.ERROR) {
+          logger.error(result.ERROR);
+          return;
+        }
+
+        this.store.items = updateArray(result?.ROW, this.store.items);
+
+        this.subscriptions.forEach((subscription) => {
+          subscription.callback({ store: this.store });
+        });
+      },
+      (response) => logger.error(response),
+      {
+        REVERSE: reverse,
+        ...(criteriaMatch != '' && { CRITERIA_MATCH: criteriaMatch }),
+      },
+    ) as SocketObservable<any>;
+  }
+
+  public subscribe(callback: SubscribeCallback, reverse: boolean, criteriaMatch: string): void {
+    if (this.stream) {
+      callback({ store: this.store });
+      return;
+    }
+
+    this.stream = this.getStream(reverse, criteriaMatch);
+    const socketSubscription = this.stream.subscribe();
+
+    this.subscriptions.push({ callback, socketSubscription });
+  }
+
+  public unsubscribe(callback: SubscribeCallback): void {
+    const index = this.subscriptions.findIndex(
+      (subscription) => subscription.callback === callback,
+    );
+
+    if (index >= 0) {
+      const found = this.subscriptions.splice(index, 1);
+      found.forEach((subscription) => {
+        subscription.socketSubscription.unsubscribe();
+        subscription.callback({ store: { items: [] } });
+      });
+    }
+
+    this.stream = undefined;
+    this.store = { items: [] };
+  }
+}
+
+export const FoundationInboxService = DI.createInterface<FoundationInboxService>((x) =>
+  x.transient(FoundationInboxServiceImpl),
+);

package/src/services/notify.service.ts

@@ -0,0 +1,21 @@
+import { Connect } from '@genesislcap/foundation-comms';
+import { DI } from '@genesislcap/web-core';
+
+export interface NotifyService {
+  getNotifyRouteTopics();
+}
+
+class NotifyServiceImpl implements NotifyService {
+  @Connect private connect: Connect;
+
+  public async getNotifyRouteTopics() {
+    const data = await this.connect.request('REQ_NOTIFY_ROUTE_TOPICS', {
+      REQUEST: { NOTIFY_ROUTE_ID: '' },
+    });
+    return data.REPLY ? data.REPLY[0].TOPICS : [];
+  }
+}
+
+export const NotifyService = DI.createInterface<NotifyService>((x) =>
+  x.singleton(NotifyServiceImpl),
+);

package/src/services/rule.service.ts

@@ -0,0 +1,129 @@
+import { Connect, Message } from '@genesislcap/foundation-comms';
+import { DI } from '@genesislcap/web-core';
+import type { Rule } from '../components/foundation-notification-dashboard/components/rules/rule-dialog/rule-dialog.types';
+
+export interface RuleService {
+  subscribeRule(dynamicRuleId: string, parameterDetails: any);
+  unsubscribeRule(dynamicRuleId: string);
+  enableRule(dynamicRuleId: string);
+  disableRule(dynamicRuleId: string);
+  getRules(): Promise<any>;
+  getRuleDetails(ruleId: string): Promise<Rule>;
+  createRule(rule: Rule): Promise<Message>;
+  updateRule(rule: Rule): Promise<Message>;
+  deleteRule(ruleId: string): void;
+}
+
+class RuleServiceImpl implements RuleService {
+  @Connect private connect: Connect;
+
+  public async getRules() {
+    const response = await this.connect.request('REQ_NOTIFICATION_RULE', { REQUEST: true });
+    return response.REPLY;
+  }
+
+  public async getRuleDetails(ruleId: string): Promise<Rule> {
+    const response = await this.connect.request('REQ_NOTIFICATION_RULE_DETAILS', {
+      REQUEST: {
+        ID: ruleId,
+      },
+    });
+
+    if (!response.REPLY) {
+      return;
+    }
+
+    return response.REPLY[0];
+  }
+
+  async createRule(rule: Rule): Promise<Message> {
+    return this.connect.commitEvent('EVENT_NOTIFICATION_RULE_CREATE', {
+      DETAILS: rule,
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  async updateRule(rule: Rule): Promise<Message> {
+    return this.connect.commitEvent('EVENT_NOTIFICATION_RULE_UPDATE', {
+      DETAILS: rule,
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  deleteRule(ruleId: string) {
+    this.connect.commitEvent('EVENT_NOTIFICATION_RULE_DELETE', {
+      DETAILS: {
+        ID: ruleId,
+      },
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  public async subscribeRule(dynamicRuleId: string, parameterDetails: unknown) {
+    if (!dynamicRuleId) {
+      console.error('Invalid dynamicRuleId');
+      return;
+    }
+
+    return this.connect.commitEvent('EVENT_NOTIFICATION_RULE_SUBSCRIBE', {
+      DETAILS: {
+        DYNAMIC_RULE_ID: dynamicRuleId,
+        PARAMETER_DETAILS: parameterDetails,
+      },
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  public async unsubscribeRule(dynamicRuleId: string) {
+    if (!dynamicRuleId) {
+      console.error('Invalid dynamicRuleId');
+      return;
+    }
+
+    return this.connect.commitEvent(
+      'EVENT_NOTIFICATION_RULE_UNSUBSCRIBE',
+      this.createDynamicRuleIDParams(dynamicRuleId),
+    );
+  }
+
+  public async enableRule(dynamicRuleId: string) {
+    if (!dynamicRuleId) {
+      console.error('Invalid dynamicRuleId');
+      return;
+    }
+
+    return this.connect.commitEvent(
+      'EVENT_NOTIFICATION_RULE_ENABLE',
+      this.createDynamicRuleIDParams(dynamicRuleId),
+    );
+  }
+
+  public async disableRule(dynamicRuleId: string) {
+    if (!dynamicRuleId) {
+      console.error('Invalid dynamicRuleId');
+      return;
+    }
+
+    return this.connect
+      .commitEvent('EVENT_NOTIFICATION_RULE_DISABLE', this.createDynamicRuleIDParams(dynamicRuleId))
+      .then((data) => {
+        console.log(data);
+      });
+  }
+
+  private createDynamicRuleIDParams(dynamicRuleId: string) {
+    return {
+      DETAILS: {
+        ID: dynamicRuleId,
+      },
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    };
+  }
+}
+
+export const RuleService = DI.createInterface<RuleService>((x) => x.singleton(RuleServiceImpl));

package/src/services/system.service.ts

@@ -0,0 +1,43 @@
+import { Connect } from '@genesislcap/foundation-comms';
+import { DI } from '@genesislcap/web-core';
+
+export type Field = {
+  FIELD_NAME: string;
+  FIELD_TYPE: string;
+};
+
+export interface SystemService {
+  getResources(): Promise<string[]>;
+  getFields(resource: string): Promise<Field[]>;
+}
+
+class SystemServiceImpl implements SystemService {
+  @Connect private connect: Connect;
+
+  public async getResources(): Promise<string[]> {
+    const response = await this.connect.request('NOTIFY_SYSTEM_ENTITY', {
+      REQUEST: { ENTITY_NAME: '*' },
+    });
+    return response.REPLY.map((table) => table.ENTITY_NAME).sort();
+  }
+
+  async getFields(resource: string): Promise<Field[]> {
+    if (!resource) {
+      return [];
+    }
+
+    const response = await this.connect.request('SYSTEM_ENTITY_FIELDS', {
+      REQUEST: {
+        ENTITY_NAME: resource,
+      },
+    });
+    return response.REPLY.sort((a, b) => a.NAME.localeCompare(b.NAME)).map((entity) => ({
+      FIELD_NAME: entity.NAME,
+      FIELD_TYPE: entity.TYPE,
+    }));
+  }
+}
+
+export const SystemService = DI.createInterface<SystemService>((x) =>
+  x.singleton(SystemServiceImpl),
+);

package/src/services/template.service.ts

@@ -0,0 +1,71 @@
+import { Connect } from '@genesislcap/foundation-comms';
+import { DI } from '@genesislcap/web-core';
+import type { Template } from '../components/foundation-notification-dashboard/components/templates/template-dialog/template-dialog.types';
+
+export interface TemplateService {
+  createRuleTemplate(ruleTemplate: Template): Promise<any>;
+  editRuleTemplate(ruleTemplate: Template): Promise<any>;
+  getRuleTemplates();
+  getRuleTemplateDetails(dynamicRuleId: string);
+  deleteRuleTemplate(dynamicRuleId: string);
+}
+
+class TemplateServiceImpl implements TemplateService {
+  @Connect private connect: Connect;
+
+  async createRuleTemplate(ruleTemplate: Template): Promise<any> {
+    return this.connect.commitEvent('EVENT_NOTIFICATION_RULE_TEMPLATE_CREATE', {
+      DETAILS: ruleTemplate,
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  async editRuleTemplate(ruleTemplate: Template): Promise<any> {
+    return this.connect.commitEvent('EVENT_NOTIFICATION_RULE_TEMPLATE_UPDATE', {
+      DETAILS: ruleTemplate,
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  public async getRuleTemplates() {
+    let ruleTemplates = [];
+    await this.connect.request('REQ_NOTIFICATION_RULE_TEMPLATE', { REQUEST: true }).then((data) => {
+      ruleTemplates = data.REPLY;
+    });
+    return ruleTemplates;
+  }
+
+  public async getRuleTemplateDetails(dynamicRuleId: string) {
+    let ruleTemplateDetails = {};
+    await this.connect
+      .request('REQ_NOTIFICATION_RULE_TEMPLATE_DETAILS', {
+        REQUEST: {
+          ID: dynamicRuleId,
+        },
+      })
+      .then((data) => {
+        if (!data.REPLY) {
+          return;
+        }
+
+        ruleTemplateDetails = data.REPLY[0];
+      });
+    return ruleTemplateDetails;
+  }
+
+  deleteRuleTemplate(dynamicRuleId: string) {
+    return this.connect.commitEvent('EVENT_NOTIFICATION_RULE_TEMPLATE_DELETE', {
+      DETAILS: {
+        ID: dynamicRuleId,
+      },
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+}
+
+export const TemplateService = DI.createInterface<TemplateService>((x) =>
+  x.singleton(TemplateServiceImpl),
+);

package/src/styles/scrollbar.styles.ts

@@ -0,0 +1,15 @@
+import { css } from '@genesislcap/web-core';
+
+export const scrollbarStyles = css`
+  ::-webkit-scrollbar {
+    width: calc((var(--base-height-multiplier) + var(--design-unit)) * 1px);
+  }
+
+  ::-webkit-scrollbar-track {
+    background: var(--neutral-layer-1);
+  }
+
+  ::-webkit-scrollbar-thumb {
+    background: var(--neutral-fill-rest);
+  }
+`;

package/src/utils/eventDetail.ts

@@ -0,0 +1,5 @@
+import { ExecutionContext } from '@genesislcap/web-core';
+
+export function eventDetail<T = any>(ctx: ExecutionContext) {
+  return (ctx.event as CustomEvent).detail as T;
+}

package/src/utils/gridConfig.ts

@@ -0,0 +1,14 @@
+export const hideColumn = {
+  hide: true,
+};
+
+export const suppressColumn = {
+  ...hideColumn,
+  suppressColumnsToolPanel: true,
+};
+
+export const hideColumns = (fieldsToSuppress: any) =>
+  fieldsToSuppress.map((columnName) => ({
+    field: columnName,
+    ...suppressColumn,
+  }));

package/src/utils/humanize.ts

@@ -0,0 +1,14 @@
+export const humanize = (s: string) => {
+  if (!s) {
+    return '';
+  }
+
+  let i;
+  const frags = s.split('_');
+
+  for (i = 0; i < frags.length; i += 1) {
+    frags[i] = frags[i].charAt(0).toUpperCase() + frags[i].slice(1).toLowerCase();
+  }
+
+  return frags.join(' ');
+};

package/src/utils/icons.ts

@@ -0,0 +1,15 @@
+import { html } from '@genesislcap/web-core';
+
+export const editIcon = html`
+  <rapid-icon
+    style="pointer-events: none; opacity: 0.5"
+    class="icon-button"
+    variant="solid"
+    name="pen"
+    size="lg"
+  ></rapid-icon>
+`;
+
+export const deleteIcon = html`
+  <rapid-icon style="opacity: 0.5" variant="regular" name="trash-alt" size="lg"></rapid-icon>
+`;

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './logger';
+export * from './humanize';
+export * from './updateArray';
+export * from './eventDetail';
+export * from './icons';
+export * from './gridConfig';

package/src/utils/logger.ts

@@ -0,0 +1,3 @@
+import { createLogger } from '@genesislcap/foundation-logger';
+
+export const logger = createLogger('pbc-notify-ui');