@genesislcap/pbc-reconciliation-ui 0.0.46 → 14.339.0

package/src/main/main.template.ts

@@ -0,0 +1,65 @@
+import { html, ref, when } from '@genesislcap/web-core';
+import { ConfigurationsPanel } from '../components/configurations-panel/configurations-panel';
+import { DataDictionaries } from '../components/data-dictionaries/data-dictionaries';
+import { List } from '../components/list/list';
+import { ReconciliationsPanel } from '../components/reconciliations-panel/reconciliations-panel';
+import { tabPanelTag, tabTag, tabsTag } from '../tags';
+import { FoundationReconciliation } from './main';
+
+export enum ReconciliationTab {
+  Configurations = 'CONFIGURATIONS',
+  Reconciliations = 'RECONCILIATIONS',
+  DataDictionariesTab = 'DATA_DICTIONARIES',
+}
+
+List;
+ConfigurationsPanel;
+ReconciliationsPanel;
+DataDictionaries;
+
+/**
+ * @public
+ */
+export const FoundationReconciliationTemplate = html<FoundationReconciliation>`
+  ${when(
+    (x) => x.ready,
+    html<FoundationReconciliation>`
+  <${tabsTag} appearance="secondary" class="tabs">
+    <${tabTag}
+      appearance="secondary"
+      slot="data-dictionaries-tab"
+      id=${ReconciliationTab.DataDictionariesTab}
+      @click=${(x) => x.tabChanged(ReconciliationTab.DataDictionariesTab)}
+    >
+      Data Dictionaries
+    </${tabTag}>
+    <${tabTag}
+      appearance="secondary"
+      slot="configurations-tab"
+      id=${ReconciliationTab.Configurations}
+      @click=${(x) => x.tabChanged(ReconciliationTab.Configurations)}
+    >
+      Configurations
+    </${tabTag}>
+    <${tabTag}
+      appearance="secondary"
+      slot="reconciliations-tab"
+      id=${ReconciliationTab.Reconciliations}
+      @click=${(x) => x.tabChanged(ReconciliationTab.Reconciliations)}
+    >
+      Reconciliations
+    </${tabTag}>
+
+    <${tabPanelTag} slot="reconciliations-tab" id="reconciliations-tab-panel">
+      <data-dictionaries></data-dictionaries>
+    </${tabPanelTag}>
+    <${tabPanelTag} slot="configurations-tab" id="configurations-tab-panel">
+      <configurations-panel ${ref('configurationsPanel')}></configurations-panel>
+    </${tabPanelTag}>
+    <${tabPanelTag} slot="reconciliations-tab" id="reconciliations-tab-panel">
+      <reconciliations-panel ${ref('reconciliationsPanel')}></reconciliations-panel>
+    </${tabPanelTag}>
+  </${tabsTag}>
+`,
+  )}
+`;

package/src/main/main.ts

@@ -0,0 +1,153 @@
+import { GenesisElement, customElement, observable } from '@genesislcap/web-core';
+import { ConfigurationsPanel } from '../components/configurations-panel/configurations-panel';
+import { DataDictionaries } from '../components/data-dictionaries/data-dictionaries';
+import { ReconciliationsPanel } from '../components/reconciliations-panel/reconciliations-panel';
+import { logger } from '../utils';
+import { FoundationReconciliationStyles as styles } from './main.styles';
+import { ReconciliationTab, FoundationReconciliationTemplate as template } from './main.template';
+
+/**
+ * FoundationReconciliation.
+ *
+ * @remarks
+ * Base MF export used by host application `configure` calls. It does not set up a design system or components. Both are
+ * expected to be registered in the host application, which should provide the details of which to the MF via
+ * TemplateOptions.
+ *
+ * See the {@link configure} hook for more information on how to set up and use this micro frontend in your application.
+ *
+ * @public
+ */
+export class FoundationReconciliation extends GenesisElement {
+  @observable ready: boolean;
+  selectedTab: ReconciliationTab = ReconciliationTab.DataDictionariesTab;
+
+  dataDictionaries: DataDictionaries;
+  configurationsPanel: ConfigurationsPanel;
+  reconciliationsPanel: ReconciliationsPanel;
+
+  async connectedCallback() {
+    super.connectedCallback();
+    this.ready = true;
+  }
+
+  async tabChanged(tab: ReconciliationTab) {
+    this.selectedTab = tab;
+
+    switch (tab) {
+      case ReconciliationTab.DataDictionariesTab:
+        break;
+      case ReconciliationTab.Configurations:
+        await this.configurationsPanel.setDataDictionaries();
+        break;
+      case ReconciliationTab.Reconciliations:
+        await this.reconciliationsPanel.setReconciliationConfigurations();
+        break;
+      default:
+        logger.error('Unexpected tab:', tab);
+        break;
+    }
+  }
+}
+
+/**
+ * RapidReconciliation.
+ *
+ * @remarks
+ * A rapid version that pre-registers rapid components and uses the rapid design system.
+ *
+ * @example
+ * ```ts
+ * import { RapidReconciliation } from '@genesislcap/pbc-documents-ui';
+ * ...
+ * RapidReconciliation
+ * ```
+ *
+ * @example Load the micro frontend on-demand
+ * ```ts
+
+ *   const { RapidReconciliation } = await import('@genesislcap/pbc-documents-ui');
+ *   return RapidReconciliation;
+ * },
+ * ```
+ *
+ * @public
+ */
+@customElement({
+  name: 'rapid-reconciliation',
+  template,
+  styles,
+})
+export class RapidReconciliation extends FoundationReconciliation {
+  /**
+   * @internal
+   */
+  async connectedCallback() {
+    await this.loadRemotes();
+    super.connectedCallback();
+  }
+
+  /**
+   * @internal
+   */
+  protected async loadRemotes() {
+    const { registerCommonRapidComponents } = await import('../components/rapid-components');
+    await registerCommonRapidComponents();
+    this.ready = true;
+  }
+}
+
+/**
+ * ZeroReconciliation.
+ *
+ * @remarks
+ * A zero version that pre-registers zero components and uses the zero design system.
+ *
+ * @example
+ * ```ts
+ * import { ZeroReconciliation } from '@genesislcap/pbc-documents-ui';
+ * ...
+ * ZeroReconciliation
+ * ```
+ *
+ * @example Load the micro frontend on-demand
+ * ```ts
+
+ *   const { ZeroReconciliation } = await import('@genesislcap/pbc-documents-ui');
+ *   return ZeroReconciliation;
+ * },
+ * ```
+ *
+ * @public
+ */
+@customElement({
+  name: 'zero-reconciliation',
+  template,
+  styles,
+})
+export class ZeroReconciliation extends FoundationReconciliation {
+  /**
+   * @internal
+   */
+  async connectedCallback() {
+    super.connectedCallback();
+    await this.loadRemotes();
+  }
+
+  /**
+   * @internal
+   */
+  protected async loadRemotes() {
+    const { registerCommonZeroComponents } = await import('../components/zero-components');
+    await registerCommonZeroComponents();
+    this.ready = true;
+  }
+}
+
+/**
+ * @privateRemarks
+ * Keeps backwards compatability with original export.
+ *
+ * @public
+ */
+export class Reconciliation extends ZeroReconciliation {}

package/src/reconciliation.types.ts

@@ -0,0 +1,170 @@
+export type Configuration = {
+  NAME?: string;
+  RECONCILIATION_CONFIG_ID?: string;
+  RECONCILIATION_STRATEGY?: string;
+  DICTIONARY_ID?: string;
+  RULES?: Array<ReconConfigurationRule>;
+  DATASOURCES?: Array<Datasource>;
+  MATCH_NULL?: boolean;
+  PRIMARY_DATASOURCE_NAME?: string;
+  PRIMARY_DATASOURCE?: string;
+};
+
+export type ReconConfigurationRule = {
+  RECONCILIATION_CONFIG_ID?: string;
+  FIELD_TYPE: FieldType;
+  FIELD_NAME: string;
+  TOLERANCE_TYPE: ToleranceType;
+  TOLERANCE_VALUE: string;
+  IS_MATCH_KEY: boolean;
+};
+
+export const ConfigurationMode = {
+  CREATE: 'create',
+  EDIT: 'edit',
+} as const;
+
+export enum RuleMode {
+  ADD = 'add',
+  EDIT = 'edit',
+}
+
+export type DataDictionary = {
+  DICTIONARY_ID: string;
+  DICTIONARY_NAME: string;
+};
+
+export type DataDictionaryField = {
+  DICTIONARY_ID?: string;
+  FIELD_NAME?: string;
+  FIELD_TYPE?: FieldType;
+};
+
+export type Datasource = {
+  NAME: string;
+  TYPE: DatasourceType;
+  CONFIG_DATA?: string;
+};
+
+export enum DatasourceType {
+  FILE = 'FILE',
+  PIPELINE = 'PIPELINE',
+}
+
+export enum ReconciliationFrequency {
+  BATCH = 'BATCH',
+  REAL_TIME = 'REALTIME',
+}
+
+export enum ReconciliationMethod {
+  ONE_TO_ONE = 'ONE_TO_ONE',
+  ONE_TO_MANY = 'ONE_TO_MANY',
+  MANY_TO_MANY = 'MANY_TO_MANY',
+}
+
+export enum FieldType {
+  STRING = 'STRING',
+  SHORT = 'SHORT',
+  INT = 'INT',
+  LONG = 'LONG',
+  DOUBLE = 'DOUBLE',
+  RAW = 'RAW',
+  BOOLEAN = 'BOOLEAN',
+  BIGDECIMAL = 'BIGDECIMAL',
+  DATETIME = 'DATETIME',
+  DATE = 'DATE',
+  NANO_TIMESTAMP = 'NANO_TIMESTAMP',
+}
+
+export enum ReconciliationStatus {
+  IN_PROGRESS = 'IN_PROGRESS',
+  COMPLETED = 'COMPLETED',
+  FAILED = 'FAILED',
+  CANCELLED = 'CANCELLED',
+}
+
+export enum ToleranceType {
+  ABSOLUTE = 'ABSOLUTE',
+  PERCENTAGE = 'PERCENTAGE',
+  EQUALITY = 'EQUALITY',
+  DAYS = 'DAYS',
+  MINUTES = 'MINUTES',
+}
+
+export type DatasourceRule = {
+  field: string;
+  type: FieldType;
+  tolerance: string;
+  primaryKey: boolean;
+};
+
+export type ReconciliationInProgress = {
+  name: string;
+};
+
+export type HistoricalReconciliation = {
+  name: string;
+  completedAt: number;
+};
+
+export type Reconciliation = {
+  RECONCILIATION_ID?: string;
+  RECONCILIATION_NAME?: string;
+  STATUS?: ReconciliationStatus;
+  DATETIME?: number;
+  INPUT_PARAMETERS?: string;
+  RECONCILIATION_CONFIG_ID?: string;
+  iconName?: string;
+  iconClass?: string;
+};
+
+export type Field = {
+  name: string;
+  type: FieldType;
+};
+
+export type ReconciliationInsert = {
+  RECONCILIATION_NAME: string;
+  RECONCILIATION_CONFIG_ID: string;
+  INPUT_PARAMETERS: {
+    [key: string]: any;
+  };
+};
+
+export type DatasourceConfiguration = {
+  NAME: string;
+  RECONCILIATION_CONFIG_ID: string;
+  INPUT_PARAMETER?: any;
+  TYPE?: string;
+  CONFIG_DATA?: string;
+  INDEX?: number;
+  RECORD_ID?: number;
+  TIMESTAMP?: number;
+};
+
+export type ReconciliationConfiguration = {
+  RECONCILIATION_CONFIG_ID: string;
+  NAME: string;
+  DICTIONARY_ID: string;
+  RECONCILIATION_STRATEGY: string; // TODO: Create Strategy type
+  PRIMARY_DATASOURCE: string;
+};
+
+export enum KeyResult {
+  MATCHED = 'MATCHED',
+  UNMATCHED = 'UNMATCHED',
+}
+
+export enum ComparisonResult {
+  MATCHED = 'MATCHED',
+  FAILED = 'FAILED',
+  MISSING_VALUE = 'MISSING_VALUE',
+}
+
+export enum MessageType {
+  EVENT_ACK = 'EVENT_ACK',
+  EVENT_NACK = 'EVENT_NACK',
+}
+
+export const CRITERIA_NO_ROWS = 'true == false';
+export const MAX_ROWS_RECONCILIATION_RESULT = 25_000;

package/src/sandbox.ts

@@ -0,0 +1,40 @@
+import { Auth, AuthType, Connect } from '@genesislcap/foundation-comms';
+import { customElement, GenesisElement, html, observable, when } from '@genesislcap/web-core';
+
+@customElement({
+  name: 'reconciliation-sandbox',
+  template: html`
+    ${when(
+      (x) => x.ready,
+      html`
+        <rapid-design-system-provider>
+          <rapid-reconciliation></rapid-reconciliation>
+        </rapid-design-system-provider>
+      `,
+    )}
+  `,
+})
+export class ReconciliationSandbox extends GenesisElement {
+  @Connect connect!: Connect;
+  @Auth auth!: Auth;
+  @observable ready = false;
+
+  async connectedCallback() {
+    super.connectedCallback();
+
+    console.log('Running with following env vars:', {
+      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;
+    });
+  }
+}

package/src/services/data-dictionary.service.ts

@@ -0,0 +1,64 @@
+import { Connect } from '@genesislcap/foundation-comms';
+import { DI } from '@genesislcap/web-core';
+
+export interface DataDictionaryService {
+  getDataDictionaries();
+  createDataDictionary(dataDictionary);
+  editDataDictionary(dataDictionary);
+  deleteDataDictionary(dataDictionary);
+  getDataDictionaryFields(dataDictionaryId);
+}
+
+class DataDictionaryServiceImpl implements DataDictionaryService {
+  @Connect private connect: Connect;
+
+  async getDataDictionaries() {
+    const response = await this.connect.request('REQ_DATA_DICTIONARY', { REQUEST: true });
+    return response.REPLY;
+  }
+
+  async createDataDictionary(dataDictionary) {
+    return this.connect.commitEvent('EVENT_DATA_DICTIONARY_INSERT', {
+      DETAILS: dataDictionary,
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  async editDataDictionary(dataDictionary) {
+    return this.connect.commitEvent('EVENT_DATA_DICTIONARY_UPDATE', {
+      DETAILS: dataDictionary,
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  async deleteDataDictionary(dataDictionaryId): Promise<boolean> {
+    const response = await this.connect.commitEvent('EVENT_DATA_DICTIONARY_DELETE', {
+      DETAILS: {
+        DICTIONARY_ID: dataDictionaryId,
+      },
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+
+    return response.MESSAGE_TYPE === 'EVENT_ACK';
+  }
+
+  async getDataDictionaryFields(dataDictionaryId) {
+    const response = await this.connect.request('REQ_DATA_DICTIONARY_FIELD', {
+      REQUEST: {
+        DICTIONARY_ID: dataDictionaryId,
+      },
+    });
+
+    return response.REPLY.map((field) => ({
+      FIELD_NAME: field.FIELD_NAME,
+      FIELD_TYPE: field.FIELD_TYPE,
+    }));
+  }
+}
+
+export const DataDictionaryService = DI.createInterface<DataDictionaryService>((x) =>
+  x.singleton(DataDictionaryServiceImpl),
+);

package/src/services/document.service.ts

@@ -0,0 +1,72 @@
+import { Auth, Connect } from '@genesislcap/foundation-comms';
+import { DI } from '@genesislcap/web-core';
+import { logger } from '../utils';
+import { getEndpointUrl } from '../utils/endpoint';
+
+export interface DocumentService {
+  uploadDocument(file: File): Promise<any>;
+  getDocumentFilename(documentId: string);
+  getAllFileStorages();
+}
+
+class DocumentServiceImpl implements DocumentService {
+  @Connect private connect: Connect;
+  @Auth private auth: Auth;
+
+  async uploadDocument(file: File): Promise<any> {
+    if (!file) {
+      logger.error('No file provided.');
+      return;
+    }
+
+    const headers = new Headers();
+    headers.append('SESSION_AUTH_TOKEN', this.auth.loggedUserResult.authToken);
+    const formData = new FormData();
+    formData.append(file.name, file);
+
+    const endpoint = getEndpointUrl('file-server/upload/');
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      body: formData,
+      headers: headers,
+    });
+
+    return response.json();
+  }
+
+  async getDocumentFilename(documentId: string) {
+    const headers = new Headers();
+    headers.append('SESSION_AUTH_TOKEN', sessionStorage.getItem('authToken'));
+
+    const endpoint = getEndpointUrl(`file-server/download?fileStorageId=${documentId}`);
+
+    let filename = '';
+
+    await fetch(endpoint, {
+      method: 'GET',
+      headers: headers,
+    }).then((response) => {
+      const contentDispositionHeader = response.headers.get('Content-disposition');
+      filename = contentDispositionHeader.split(';')[1].split('filename')[1].split('=')[1].trim();
+    });
+
+    return filename;
+  }
+
+  async getAllFileStorages() {
+    const response = await this.connect.snapshot('ALL_FILE_STORAGES', {
+      CRITERIA_MATCH: `Expr.containsIgnoreCase(FILE_NAME, '.csv')`,
+    });
+
+    if (response.ERROR) {
+      logger.error(response.ERROR);
+      return;
+    }
+
+    return response.ROW;
+  }
+}
+
+export const DocumentService = DI.createInterface<DocumentService>((x) =>
+  x.singleton(DocumentServiceImpl),
+);

package/src/services/reconciliation-configuration.service.ts

@@ -0,0 +1,105 @@
+import { Connect, Message } from '@genesislcap/foundation-comms';
+import { DI } from '@genesislcap/web-core';
+
+export interface ReconciliationConfigurationService {
+  getReconciliationConfigurations(): Promise<any>;
+  getReconciliationConfigurationDetails(configurationId: string): Promise<any>;
+  getReconciliationConfigurationRules(configurationId: string): Promise<any>;
+  getReconciliationDatasourceConfiguration(configurationId: string): Promise<Array<any>>;
+  getReconciliationDataPipelines(): Promise<any>;
+  createReconciliationConfiguration(configuration: any): Promise<Message>;
+  updateReconciliationConfiguration(configuration: any): Promise<Message>;
+  deleteReconciliationConfiguration(configurationId: string): void;
+}
+
+class ReconciliationConfigurationServiceImpl implements ReconciliationConfigurationService {
+  @Connect private connect: Connect;
+
+  public async getReconciliationConfigurations() {
+    const response = await this.connect.request('REQ_RECONCILIATION_CONFIG', { REQUEST: true });
+    return response.REPLY;
+  }
+
+  public async getReconciliationConfigurationDetails(configurationId: string): Promise<any> {
+    const response = await this.connect.request('REQ_RECONCILIATION_CONFIG', {
+      REQUEST: {
+        RECONCILIATION_CONFIG_ID: configurationId,
+      },
+    });
+
+    if (!response.REPLY) {
+      return;
+    }
+
+    return response.REPLY[0];
+  }
+
+  public async getReconciliationConfigurationRules(configurationId: string): Promise<any> {
+    const response = await this.connect.request('REQ_RECONCILIATION_RULE', {
+      REQUEST: {
+        RECONCILIATION_CONFIG_ID: configurationId,
+      },
+    });
+
+    if (!response.REPLY) {
+      return;
+    }
+
+    return response.REPLY;
+  }
+
+  public async getReconciliationDatasourceConfiguration(configurationId: string): Promise<any> {
+    const response = await this.connect.request('REQ_DATASOURCE_CONFIG', {
+      REQUEST: {
+        RECONCILIATION_CONFIG_ID: configurationId,
+      },
+    });
+
+    if (!response.REPLY) {
+      return;
+    }
+
+    return response.REPLY;
+  }
+
+  public async getReconciliationDataPipelines(): Promise<any> {
+    const response = await this.connect.request('REQ_RECONCILIATION_DATA_PIPELINES', {
+      REQUEST: true,
+    });
+    if (!response.REPLY) {
+      return;
+    }
+    return response.REPLY[0];
+  }
+
+  async createReconciliationConfiguration(configuration: any): Promise<Message> {
+    return this.connect.commitEvent('EVENT_RECONCILIATION_CONFIG_INSERT', {
+      DETAILS: configuration,
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  async updateReconciliationConfiguration(configuration: any): Promise<Message> {
+    return this.connect.commitEvent('EVENT_RECONCILIATION_CONFIG_UPDATE', {
+      DETAILS: configuration,
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+
+  deleteReconciliationConfiguration(configurationId: string) {
+    return this.connect.commitEvent('EVENT_RECONCILIATION_CONFIG_DELETE', {
+      DETAILS: {
+        RECONCILIATION_CONFIG_ID: configurationId,
+      },
+      IGNORE_WARNINGS: true,
+      VALIDATE: false,
+    });
+  }
+}
+
+export const ReconciliationConfigurationService =
+  DI.createInterface<ReconciliationConfigurationService>((x) =>
+    x.singleton(ReconciliationConfigurationServiceImpl),
+  );