@cellaware/utils 7.2.5 → 8.0.0

package/dist/chatwms/alerts.d.ts

@@ -0,0 +1,86 @@
+import { DataContext } from "./client.js";
+import { DatagridCondition, DatagridStateBase } from "./datagrid.js";
+export declare const ALERT_VISIBILITY_PRIVATE = "private";
+export declare const ALERT_VISIBILITY_PUBLIC = "public";
+/**
+ * Alert Strategy
+ *
+ * The strategy influences alert sending behavior when the previous alert execution
+ * resulted in the condition being met/alert being sent. Traditionally, alert systems
+ * will just send notifications over and over while the condition is met. This may be
+ * good sometimes, but could be very annoying otherwise. The strategy allows users to
+ * configure this behavior.
+ *
+ *  - once: will send once when the condition is met and will not send again until the condition
+ *    is no longer met
+ *  - change: if the condition is met, will send if there was a meaningful change in the data
+ *    since last execution
+ *  - always: sends every time as long as the condition is met
+ */
+export declare const ALERT_STRATEGY_ONCE = "once";
+export declare const ALERT_STRATEGY_CHANGE = "change";
+export declare const ALERT_STRATEGY_ALWAYS = "always";
+export interface Alert {
+    alertId: string;
+    alertTitle: string;
+    enabled: boolean;
+    visibility: string;
+    readonly: boolean;
+    folder: string;
+    strategy: string;
+    contentInfo: AlertContentInfo;
+    conditionInfo: DatagridCondition;
+    clientId: string;
+    userId: string;
+}
+export declare function initAlert(): Alert;
+export interface InstanceAlert extends Alert {
+    subscriptions: AlertSubscription[];
+}
+export interface AlertWithSubscriptions extends Alert {
+    subscriptions: AlertSubscriptionType[];
+    lastMet: string;
+    lastSent: string;
+}
+export interface AlertContentInfo extends DatagridStateBase {
+    contextName: DataContext;
+    specification: string;
+    query: string;
+    summary: string;
+    reviewOk?: boolean;
+    reviewConfidence?: string;
+    reviewFeedback?: string;
+    tableGroups?: string[];
+    developer?: boolean;
+}
+export interface AlertTestResult {
+    met: boolean;
+    rows: any[];
+    hashedRows: string[];
+}
+export declare function initAlertTestResult(): AlertTestResult;
+export interface AlertExecution {
+    alertId: string;
+    alertTitle: string;
+    strategy: string;
+    conditionInfo: DatagridCondition;
+    met: boolean;
+    hashedRows: string[];
+    error: string;
+    sent: boolean;
+    clientId: string;
+    customer: string;
+    warehouse: string;
+    userId: string;
+    datetime: Date;
+}
+export type AlertSubscriptionType = 'popup' | 'email' | 'teams';
+export declare const ALERT_SUBSCRIPTION_TYPES: string[];
+export interface AlertSubscription {
+    alertId: string;
+    type: AlertSubscriptionType;
+    clientId: string;
+    userId: string;
+    userDetails: string;
+}
+export declare function initAlertSubscription(): AlertSubscription;

package/dist/chatwms/alerts.js

@@ -0,0 +1,62 @@
+import { CHATWMS_CONTEXT_NAME } from "./client.js";
+import { initDatagridCondition } from "./datagrid.js";
+export const ALERT_VISIBILITY_PRIVATE = 'private';
+export const ALERT_VISIBILITY_PUBLIC = 'public';
+/**
+ * Alert Strategy
+ *
+ * The strategy influences alert sending behavior when the previous alert execution
+ * resulted in the condition being met/alert being sent. Traditionally, alert systems
+ * will just send notifications over and over while the condition is met. This may be
+ * good sometimes, but could be very annoying otherwise. The strategy allows users to
+ * configure this behavior.
+ *
+ *  - once: will send once when the condition is met and will not send again until the condition
+ *    is no longer met
+ *  - change: if the condition is met, will send if there was a meaningful change in the data
+ *    since last execution
+ *  - always: sends every time as long as the condition is met
+ */
+export const ALERT_STRATEGY_ONCE = 'once';
+export const ALERT_STRATEGY_CHANGE = 'change';
+export const ALERT_STRATEGY_ALWAYS = 'always';
+export function initAlert() {
+    return {
+        alertId: '',
+        alertTitle: '',
+        enabled: false,
+        visibility: ALERT_VISIBILITY_PRIVATE,
+        readonly: false,
+        folder: '',
+        strategy: ALERT_STRATEGY_ONCE,
+        contentInfo: initAlertContentInfo(),
+        conditionInfo: initDatagridCondition(),
+        clientId: '',
+        userId: ''
+    };
+}
+function initAlertContentInfo() {
+    return {
+        contextName: CHATWMS_CONTEXT_NAME,
+        specification: '',
+        query: '',
+        summary: ''
+    };
+}
+export function initAlertTestResult() {
+    return {
+        met: false,
+        rows: [],
+        hashedRows: []
+    };
+}
+export const ALERT_SUBSCRIPTION_TYPES = ['popup', 'email', 'teams'];
+export function initAlertSubscription() {
+    return {
+        alertId: '',
+        type: 'email',
+        clientId: '',
+        userId: '',
+        userDetails: ''
+    };
+}

package/dist/chatwms/client.d.ts

@@ -1,4 +1,8 @@
 export declare const CHATWMS_GENERIC_CLIENT_ID = "chatwms";
+export declare const CHATWMS_CONTEXT_NAME = "chatwms";
+export declare const DATABASE_CONTEXT_NAME = "database";
+export declare const COSMOS_CONTEXT_NAME = "cosmos";
+export type DataContext = 'chatwms' | 'database' | 'cosmos';
 export declare function chatwmsGetClientId(customer: string, warehouse: string): string;
 export declare function chatwmsGetWarehouseFromClientId(clientId: string, customer: string): string;
 export declare function chatwmsGetWarehouse(warehouse: string, organization?: string): string;

package/dist/chatwms/client.js

@@ -1,4 +1,7 @@
 export const CHATWMS_GENERIC_CLIENT_ID = 'chatwms';
+export const CHATWMS_CONTEXT_NAME = 'chatwms';
+export const DATABASE_CONTEXT_NAME = 'database';
+export const COSMOS_CONTEXT_NAME = 'cosmos';
 export function chatwmsGetClientId(customer, warehouse) {
     return `${customer}_${warehouse}`;
 }

package/dist/chatwms/dashboards.d.ts

@@ -0,0 +1,80 @@
+import { DataContext } from "./client.js";
+import { DatagridStateBase } from "./datagrid.js";
+export declare const DASHBOARD_VISIBILITY_PRIVATE = "private";
+export declare const DASHBOARD_VISIBILITY_PUBLIC = "public";
+export declare const DASHBOARD_VISIBILITY_GLOBAL = "global";
+export interface DashboardFilter {
+    sequence: number;
+    name: string;
+    sortDescending: boolean;
+    defaultValue: boolean;
+}
+export interface DashboardParameter {
+    sequence: number;
+    name: string;
+    required: boolean;
+    exampleValue: string;
+}
+export interface Dashboard {
+    dashboardId: string;
+    dashboardTitle: string;
+    dashboardRoute: string;
+    visibility: string;
+    readonly: boolean;
+    filters: DashboardFilter[];
+    parameters: DashboardParameter[];
+    folder: string;
+    clientId: string;
+    userId: string;
+}
+export declare function initDashboard(): Dashboard;
+export interface WidgetDashboardFilter {
+    sequence: number;
+    filterName: string;
+    columnName: string;
+}
+export interface WidgetDashboardParameter {
+    sequence: number;
+    parameterName: string;
+    columnName: string;
+}
+export interface DashboardWidgetContentInfo extends DatagridStateBase {
+    visualizationOption: string;
+    dashboardFilters: WidgetDashboardFilter[];
+    dashboardParameters: WidgetDashboardParameter[];
+    contextName: DataContext;
+    specification: string;
+    query: string;
+    summary: string;
+    reviewOk?: boolean;
+    reviewConfidence?: string;
+    reviewFeedback?: string;
+    tableGroups?: string[];
+    developer?: boolean;
+    archive?: boolean;
+    referenceWidgetId?: string;
+}
+export interface DashboardWidgetLayoutInfo {
+    id: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface DashboardWidget {
+    widgetId: string;
+    widgetTitle: string;
+    dashboardId: string;
+    contentInfo: DashboardWidgetContentInfo;
+    layoutInfo: DashboardWidgetLayoutInfo;
+    clientId: string;
+    userId: string;
+}
+export interface DashboardUsage {
+    dashboardId: string;
+    dashboardTitle: string;
+    visibility: string;
+    clientId: string;
+    userId: string;
+    datetime: Date;
+}

package/dist/chatwms/dashboards.js

@@ -0,0 +1,17 @@
+export const DASHBOARD_VISIBILITY_PRIVATE = 'private';
+export const DASHBOARD_VISIBILITY_PUBLIC = 'public';
+export const DASHBOARD_VISIBILITY_GLOBAL = 'global';
+export function initDashboard() {
+    return {
+        dashboardId: '',
+        dashboardTitle: '',
+        dashboardRoute: '',
+        visibility: DASHBOARD_VISIBILITY_PRIVATE,
+        readonly: false,
+        filters: [],
+        parameters: [],
+        folder: '',
+        clientId: '',
+        userId: ''
+    };
+}

package/dist/chatwms/datagrid.d.ts

@@ -0,0 +1,120 @@
+export interface DatagridStateBase {
+    columnState?: ColumnState[];
+    columnGroupState?: any[];
+    isPivotMode?: boolean;
+    filterModel?: FilterModel;
+    columnFormats?: ColumnFormat[];
+}
+export interface DatagridState extends DatagridStateBase {
+    adjRowData: any[];
+    chartRowData: any[];
+}
+export declare function initDatagridState(): DatagridState;
+export type ColumnState = {
+    colId: string;
+    hide?: boolean | null;
+    sort?: 'asc' | 'desc' | null;
+    sortIndex?: number | null;
+    aggFunc?: string | null;
+    pivot?: boolean;
+    pivotIndex?: number | null;
+    rowGroup?: boolean;
+    rowGroupIndex?: number | null;
+};
+type FilterType = 'text' | 'number' | 'set';
+type Operator = 'AND' | 'OR';
+type SimpleCondition = {
+    filterType: FilterType;
+    type: string;
+    filter?: any;
+    filterTo?: any;
+    values?: any[];
+};
+type CompoundFilter = {
+    filterType: FilterType;
+    operator: Operator;
+    conditions: SimpleCondition[];
+};
+type ColumnFilter = SimpleCondition | CompoundFilter;
+type FilterModel = Record<string, ColumnFilter>;
+export interface ColumnFormat {
+    name: string;
+    displayName: string;
+    /** `text` | `number` | `date` | `boolean` */
+    type: string;
+    valueFormat: ValueFormat;
+    conditionalFormats: ConditionalFormat[];
+}
+export declare const DEFAULT_VALUE_FORMAT_VALUE = "none";
+export interface ValueFormat {
+    /** `none` | `lower` | `upper` | `title` */
+    txtCaseVal: string;
+    /** `none` | `0` | `1` | `2` | `3` | `4` */
+    numRoundVal: string;
+    /** `none` | `on` */
+    numCommaVal: string;
+    /** `none` | `dollar` */
+    numCurrencyVal: string;
+    /** `none` | `1` | `100` */
+    numPercentVal: string;
+    /** `none` | `slash` | `dash` */
+    dteSeparatorVal: string;
+    /** `none` | `numeric` | `2-digit` */
+    dteYearVal: string;
+    /** `none` | `numeric` | `2-digit` | `long` | `short` */
+    dteMonthVal: string;
+    /** `none` | `numeric` | `2-digit` */
+    dteDayVal: string;
+    /** `none` | `long` | `short` */
+    dteWeekdayVal: string;
+    /** `none` | `h12` | `h24` (we will translate to `h23`) */
+    dteHourcycleVal: string;
+    /** `none` | `numeric` | `2-digit` */
+    dteHourVal: string;
+    /** `none` | `numeric` | `2-digit` */
+    dteMinuteVal: string;
+    /** `none` | `numeric` | `2-digit` */
+    dteSecondVal: string;
+}
+export declare function evaluateValueFormat(colFmt: ColumnFormat, value: any, locale: string): any;
+export declare function formatNumberEnabled(fmt: ValueFormat): boolean;
+export declare enum ConditionalFormatRule {
+    CONTAINS = "conditional-format-rule-contains",
+    DOES_NOT_CONTAIN = "conditional-format-rule-does-not-contain",
+    BEGINS_WITH = "conditional-format-rule-begins-with",
+    ENDS_WITH = "conditional-format-rule-ends-with",
+    GREATER_THAN = "conditional-format-rule-greater-than",
+    GREATER_THAN_OR_EQUAL_TO = "conditional-format-rule-greater-than-or-equal-to",
+    LESS_THAN = "conditional-format-rule-less-than",
+    LESS_THAN_OR_EQUAL_TO = "conditional-format-rule-less-than-or-equal-to",
+    BETWEEN = "conditional-format-rule-between",
+    EQUALS = "conditional-format-rule-equals",
+    DOES_NOT_EQUAL = "conditional-format-rule-does-not-equal",
+    BLANK = "conditional-format-rule-blank",
+    NOT_BLANK = "conditional-format-rule-not-blank"
+}
+export declare const CONDITIONAL_FORMAT_RULES: string[];
+export declare const CONDITIONAL_FORMAT_RULES_TEXT: string[];
+export declare const CONDITIONAL_FORMAT_RULES_NUMBER: string[];
+export declare const CONDITIONAL_FORMAT_RULES_BOOLEAN: string[];
+export interface ConditionalFormat {
+    sequence: number;
+    rule: string;
+    value: string;
+    value2?: string;
+    style: string;
+    row: boolean;
+}
+export interface DatagridCondition {
+    columnName: string;
+    /** `text` | `number` | `date` | `boolean` */
+    dataType: string;
+    rule: string;
+    value: string;
+    value2?: string;
+}
+export declare function initDatagridCondition(): DatagridCondition;
+export declare function summarizeCondition(condition: DatagridCondition, localeMessageFn: (language: string, messageId: string) => Promise<string>): Promise<string>;
+export declare function codifyCondition(condition: DatagridCondition): string;
+export declare function transformDatagrid(rows: any[], datagridState: DatagridStateBase, locale: string, condition?: DatagridCondition): DatagridState;
+export {};