@genesislcap/pbc-reporting-ui 15.19.0 → 15.19.1

package/src/new/main/edit-config/scheduling/scheduling.ts

@@ -1,101 +0,0 @@
-import { Connect, logger } from '@genesislcap/foundation-comms';
-import {
-  showNotificationDialog,
-  showNotificationToast,
-} from '@genesislcap/foundation-notifications';
-import {
-  customElement,
-  GenesisElement,
-  observable,
-  classNames,
-  volatile,
-} from '@genesislcap/web-core';
-import { actions, selectors } from '../../../store';
-import { prioritySorter } from '../../../utils';
-import { styles } from './scheduling.styles';
-import { template } from './scheduling.template';
-
-@customElement({
-  name: 'scheduling-config',
-  template,
-  styles,
-})
-export class Scheduling extends GenesisElement {
-  @Connect connect!: Connect;
-
-  @observable timeZones;
-
-  @volatile
-  get disabledClassNames(): string {
-    return classNames(['disabled', !selectors.baseConfig.getConfig().SCHEDULE]);
-  }
-
-  @volatile
-  get enableSchedules(): boolean {
-    return selectors.baseConfig.getConfig().SCHEDULE !== undefined;
-  }
-
-  connectedCallback() {
-    super.connectedCallback();
-    this.getTimeZones();
-  }
-
-  async getTimeZones(): Promise<void> {
-    const priorityTimezones = ['Europe/London', 'America/New_York'];
-    try {
-      const response = await this.connect.request('VALID_TIME_ZONE', {
-        REQUEST: {},
-      });
-      if (!response.REPLY || !Array.isArray(response.REPLY))
-        throw new Error('Invalid data returned for Timezones');
-      this.timeZones = response.REPLY.map((e) => e.ZONE_ID).sort(
-        prioritySorter(priorityTimezones, (x) => x),
-      );
-    } catch (e: unknown) {
-      showNotificationToast(
-        {
-          title: 'Edit Report Config',
-          body: `Unable to fetch timezones data.`,
-          toast: { type: 'critical' as any },
-        },
-        'rapid',
-      );
-      logger.error(e);
-    }
-  }
-
-  toggleSchedule() {
-    if (this.enableSchedules) {
-      showNotificationDialog(
-        {
-          title: 'Reporting Config',
-          body: 'Disabling schedule will remove the current schedule. Do you want to continue?',
-          dialog: {
-            confirmingActions: [
-              {
-                label: 'Confirm',
-                action: () => {
-                  actions.baseConfig.deleteSchedule();
-                },
-              },
-            ],
-            dismissingAction: {
-              label: 'Dismiss',
-              action: () => console.log('Keep schedules'),
-            },
-          },
-        },
-        'rapid',
-      );
-    } else {
-      actions.baseConfig.updateState({
-        key: 'SCHEDULE',
-        value: {
-          TIME_ZONE:
-            this.timeZones.length > 0 ? Intl.DateTimeFormat().resolvedOptions().timeZone : '',
-          CRON_EXPRESSION: '0 0 0 * * ?',
-        },
-      });
-    }
-  }
-}

package/src/new/main/edit-config/shared/datasource-data-base-component.helpers.ts.ts

@@ -1,250 +0,0 @@
-import { CellClassParams, CellStyle } from '@ag-grid-community/core';
-import type { JSONSchema7 } from 'json-schema';
-import type { DatasourceInputTypes, DatasourceName } from '../../../store';
-import { actions, selectors } from '../../../store';
-import { Display, Genesis } from '../../../types';
-import {
-  datasourceInputForDisplay,
-  datasourceInputFromDisplay,
-  showNotificationToast,
-} from '../../../utils';
-import {
-  GridColumnNames,
-  GridRowData,
-  INVALID_COLUMN_TYPES,
-} from './datasource-data-base-component.types';
-
-// Re-export GridColumnNames for use in other modules
-export { GridColumnNames };
-
-/**
- * Converts a string to path format used by the APIs
- */
-export function convertToPathFormat(input: string): string {
-  return '/req-' + input.toLowerCase().replace(/_/g, '-');
-}
-
-/**
- * Maps schema properties to row data for grid display
- */
-export function pathParameters(datasource: {
-  name: string;
-  spec: Genesis.JSONSchema7;
-}): GridRowData[] {
-  if (!datasource.spec.properties)
-    throw new Error(`No properties on schema for datasource ${datasource.name}`);
-
-  // Extract enum values from a schema, handling both direct and oneOf patterns
-  const extractEnumValues = (schema: any, fieldName: string): string[] => {
-    if (schema.enum) {
-      // If there's a top-level enum property, use it
-      return schema.enum as string[];
-    }
-
-    if (schema.oneOf) {
-      // Look for enum values within the oneOf structure
-      const stringTypeSchema = schema.oneOf.find(
-        (s: any) => s.type === 'string' && Array.isArray(s.enum),
-      );
-
-      if (stringTypeSchema && stringTypeSchema.enum) {
-        return stringTypeSchema.enum as string[];
-      }
-    }
-
-    throw new Error(`Could not extract enum values for field '${fieldName}'`);
-  };
-
-  return Object.entries(datasource.spec.properties).map(([name, schema]) => ({
-    [GridColumnNames.ColumnName]: name,
-    [GridColumnNames.DisplayName]: name,
-    [GridColumnNames.Type]: schema.genesisType,
-    [GridColumnNames.Datasource]: datasource.name,
-    ...(schema.genesisType === 'ENUM'
-      ? { [GridColumnNames.EnumValues]: extractEnumValues(schema, name) }
-      : {}),
-  }));
-}
-
-/**
- * Determines if a column should be disabled based on its type
- */
-export function shouldDisableColumn(data: Pick<GridRowData, GridColumnNames.Type>): boolean {
-  return !data[GridColumnNames.Type] || INVALID_COLUMN_TYPES.includes(data[GridColumnNames.Type]);
-}
-
-/**
- * Configures disabled columns by marking them as filtered
- */
-export function configureDisabledColumns(
-  data: Pick<
-    GridRowData,
-    GridColumnNames.ColumnName | GridColumnNames.Datasource | GridColumnNames.Type
-  >,
-): GridRowData {
-  const shouldDisable = shouldDisableColumn(data);
-  if (shouldDisable) {
-    actions.datasourceConfig.setColumnIncluded({
-      key: datasourceNameFromDisplay(data[GridColumnNames.Datasource]),
-      column: data[GridColumnNames.ColumnName],
-      included: false,
-    });
-  }
-  return data as GridRowData;
-}
-
-/**
- * Checks if a column is filtered in the current configuration
- */
-export function lookupColumnIsIncluded(
-  data: Pick<GridRowData, GridColumnNames.Datasource | GridColumnNames.ColumnName>,
-): boolean {
-  return (
-    selectors.datasourceConfig.getDatasource(
-      datasourceNameFromDisplay(data[GridColumnNames.Datasource]),
-    ).TRANSFORMER_CONFIGURATION.INCLUDE_COLUMNS ?? []
-  ).includes(data[GridColumnNames.ColumnName]);
-}
-
-/**
- * Checks if a column is filtered in the current configuration
- */
-export function lookupColumnIsRenamed(
-  data: Pick<GridRowData, GridColumnNames.Datasource | GridColumnNames.ColumnName>,
-): boolean {
-  return Object.keys(
-    selectors.datasourceConfig.getDatasource(
-      datasourceNameFromDisplay(data[GridColumnNames.Datasource]),
-    ).TRANSFORMER_CONFIGURATION.COLUMN_RENAMES ?? {},
-  ).includes(data[GridColumnNames.ColumnName]);
-}
-
-/**
- * Converts display-formatted datasource name to internal key format
- */
-export function datasourceNameFromDisplay(input: string): DatasourceName {
-  const parts = input
-    .replace(/[)]/g, '')
-    .split('(')
-    .map((x) => x.trim());
-  const type = datasourceInputFromDisplay(parts[1] as Display.DatasourceInputTypes);
-  const name = parts[0];
-
-  const match = Object.entries(selectors.datasourceConfig.getAllConfigSet()).find(
-    ([_, ds]) => ds.KEY === name && ds.INPUT_TYPE === type,
-  );
-
-  if (!match) {
-    /**
-     * This can occur when the datasource is first being initialized and the name
-     * hasn't yet been persisted to the store.
-     */
-    return `${type}_${name}_${name}` as DatasourceName;
-  }
-
-  return match[0] as DatasourceName;
-}
-
-/**
- * Formats datasource name for display
- */
-export function datasourceNameForDisplay(datasource: string, type: DatasourceInputTypes): string {
-  return `${datasource} (${datasourceInputForDisplay(type)})`;
-}
-
-/**
- * Factory for creating cell styles based on filter status
- */
-export function buildCellStyle<
-  T extends Pick<GridRowData, GridColumnNames.Datasource | GridColumnNames.ColumnName>,
->(rowDeselectedStyle: CellStyle, rowSelectedStyle: CellStyle = {}) {
-  return (params: CellClassParams<T>): CellStyle => {
-    if (params.data && lookupColumnIsIncluded(params.data as any)) {
-      return rowSelectedStyle;
-    }
-    return rowDeselectedStyle;
-  };
-}
-
-/**
- * Common error handler for grid components
- */
-export function handleGridError(error: Error, body: string): void {
-  console.error(error);
-  console.trace();
-  showNotificationToast({
-    title: 'Reporting Config',
-    body,
-    toast: { type: 'critical' as any },
-  });
-}
-
-/**
- * Maps Genesis field types to renderer types
- */
-export function mapTypeToRenderer(
-  type: Genesis.GenesisFieldTypes,
-): 'string' | 'number' | 'boolean' | null {
-  if (['STRING', 'ENUM'].includes(type)) {
-    return 'string';
-  } else if (['INT', 'SHORT', 'DOUBLE', 'LONG', 'BIGDECIMAL'].includes(type)) {
-    return 'number';
-  } else if (['BOOLEAN'].includes(type)) {
-    return 'boolean';
-  } else {
-    console.warn(`No renderer available for type: ${type}`);
-    return null;
-  }
-}
-
-/**
- * Common implementation for fetching and processing datasource schemas
- */
-export async function fetchDatasourceSpecs(
-  datasourceName: DatasourceName | null,
-  getSchema: (name: string) => Promise<JSONSchema7>,
-  onError: (error: Error, message: string) => void,
-): Promise<{ name: string; spec: JSONSchema7 }[]> {
-  if (datasourceName === null) {
-    return [];
-  }
-
-  try {
-    return await Promise.all(
-      Object.entries(selectors.datasourceConfig.getAllConfigSet())
-        .filter(([key, ds]) => ds.INPUT_TYPE === 'REQ_REP' && key === datasourceName)
-        .map(async ([_, { KEY, NAME }]) => ({
-          spec: await getSchema(NAME), // Fetch schema by Resource Name
-          name: datasourceNameForDisplay(KEY, 'REQ_REP'), // Display Alias
-        })),
-    );
-  } catch (e) {
-    onError(e as Error, 'There were errors when requesting datasource metadata');
-    return [];
-  }
-}
-
-/**
- * Orders rows using INCLUDE_COLUMNS from the store configuration.
- */
-export function orderRowsByIncludeColumns(
-  rows: GridRowData[],
-  includeColumns?: string[],
-): GridRowData[] {
-  if (!rows || rows.length === 0) return rows;
-  if (!Array.isArray(includeColumns) || includeColumns.length === 0) return rows;
-
-  const indexMap = new Map<string, number>(includeColumns.map((c, i) => [c, i]));
-  const present: GridRowData[] = [];
-  const absent: GridRowData[] = [];
-  for (const r of rows) {
-    if (indexMap.has(r[GridColumnNames.ColumnName] as string)) present.push(r);
-    else absent.push(r);
-  }
-  present.sort(
-    (a, b) =>
-      (indexMap.get(a[GridColumnNames.ColumnName] as string) ?? 0) -
-      (indexMap.get(b[GridColumnNames.ColumnName] as string) ?? 0),
-  );
-  return [...present, ...absent];
-}