@tuki-io/tuki-widgets 0.0.177 → 0.0.178

package/contact-center/cc-script-editor/types/wxcc.d.ts

@@ -0,0 +1,161 @@
+import { EdgeDataDefinition } from 'cytoscape';
+import { ReadonlyExtendedActivity, ReadonlyExtendedLink } from './extended-activity';
+export type Variable = Readonly<{
+    name: string;
+    description?: string;
+    id?: string;
+    type: string;
+    value: any;
+    isSecure?: boolean;
+    isCAD?: boolean;
+    desktopLabel?: string;
+    isAgentEditable?: boolean;
+    source?: string;
+    isReportable?: boolean;
+    overwrite?: boolean;
+    isExternalized?: boolean;
+    resourceType?: string;
+    hints?: string[];
+    isParameter?: boolean;
+    metaAttributes?: number;
+    usedByWfIds?: number[];
+}>;
+export type Resources = Readonly<{
+    aefFile?: string;
+    audioFiles?: string[];
+    audioFilesCount?: number;
+    generatedAt?: string;
+    variableCount?: number;
+    variables?: Variable[];
+}>;
+export interface IWxCCJSON {
+    readonly schema: string;
+    readonly aefFile: string;
+    readonly generatedAt: string;
+    readonly activities: ReadonlyExtendedActivity[];
+    readonly links: ReadonlyExtendedLink[];
+    readonly prefix?: string;
+    readonly resources?: Resources;
+    readonly warnings?: any[];
+}
+type WithLabel = {
+    label: string;
+};
+export type WxCCFlowchartNode = {
+    data: ReadonlyExtendedActivity & WithLabel;
+};
+export type WxCCFlowchartEdge = {
+    data: ReadonlyExtendedLink & EdgeDataDefinition & WithLabel;
+};
+export interface IWxCCFlowchart {
+    readonly flowId?: string;
+    readonly flowName?: string;
+    readonly nodes: WxCCFlowchartNode[];
+    readonly edges: WxCCFlowchartEdge[];
+}
+export type NonIRActivityGroup = 'start' | 'end' | 'terminating-action' | 'action' | 'enum-gateway' | 'boolean-gateway' | 'unmapped' | string;
+export type NonIRWidgetType = 'activity' | 'link' | string;
+export type NonIRWidgetNodeType = 'start' | 'end' | 'terminating-action' | 'action' | 'enum-gateway' | 'boolean-gateway' | 'unmapped' | string;
+export type NonIRActivity = Readonly<{
+    id: string;
+    group: NonIRActivityGroup;
+    name: string;
+    properties: Record<string, any>;
+}>;
+export type NonIRLink = {
+    id: string;
+    sourceActivityId: string;
+    targetActivityId: string;
+    sourceId?: string;
+    targetId?: string;
+    conditionExpr?: string;
+    properties: Record<string, any>;
+};
+export type NonIRPoint = Readonly<{
+    x: number;
+    y: number;
+}>;
+export type NonIRWidget = Readonly<{
+    id: string;
+    type: NonIRWidgetNodeType | 'arrow';
+    widgetType: NonIRWidgetType;
+    label?: string;
+    point?: NonIRPoint;
+    ports?: Array<Record<string, any>>;
+    properties?: Record<string, any>;
+    points?: Array<Record<string, any>>;
+    sourcePort?: Record<string, any>;
+    targetPort?: Record<string, any>;
+}>;
+export type NonIRProcess = Readonly<{
+    activities: Record<string, NonIRActivity>;
+    links: NonIRLink[];
+}>;
+export type NonIRDiagram = Readonly<{
+    widgets: Record<string, NonIRWidget>;
+    properties?: {
+        offsetX?: number;
+        offsetY?: number;
+        zoom?: number;
+        gridSize?: number;
+        [key: string]: any;
+    };
+}>;
+export type NonIREventFlow = Readonly<{
+    id: string;
+    name?: string;
+    description?: string;
+    process: NonIRProcess;
+    onEvents?: Record<string, string>;
+    diagram?: NonIRDiagram;
+}>;
+export type NonIREventFlows = Readonly<{
+    eventsMap: Record<string, NonIREventFlow>;
+    properties?: Record<string, any>;
+    __typename?: string;
+}>;
+export type NonIRVariableOrders = Readonly<Record<string, Array<{
+    name: string;
+    variableSeq: string;
+}>>>;
+export type NonIRSetting = Readonly<{
+    name: string;
+    value: string;
+    type: string;
+    group: string;
+    __typename?: string;
+}>;
+export interface IWxCCNonIRJSON {
+    readonly orgId?: string;
+    readonly version?: number;
+    readonly id?: string;
+    readonly flowType?: string;
+    readonly name?: string;
+    readonly description?: string;
+    readonly comment?: string | null;
+    readonly variables?: Variable[];
+    readonly process: NonIRProcess;
+    readonly diagram?: NonIRDiagram;
+    readonly variableOrders?: NonIRVariableOrders;
+    readonly eventFlows?: NonIREventFlows;
+    readonly runtimeVariables?: any[];
+    readonly validating?: boolean;
+    readonly persist?: boolean;
+    readonly validationResults?: any[];
+    readonly createdBy?: string;
+    readonly createdDate?: string;
+    readonly lastModifiedBy?: string;
+    readonly lastModifiedDate?: string;
+    readonly settings?: NonIRSetting[];
+    readonly __typename?: string;
+    readonly [key: string]: any;
+}
+export type WxCCSyncDocuments = Readonly<{
+    ir: IWxCCJSON;
+    nonIr: IWxCCNonIRJSON;
+}>;
+export interface IWxCCSyncMapper {
+    toIR(nonIr: IWxCCNonIRJSON): IWxCCJSON;
+    toNonIR(ir: IWxCCJSON, baselineNonIr: IWxCCNonIRJSON): IWxCCNonIRJSON;
+}
+export {};

package/contact-center/cc-script-editor/utils/node-html-template.d.ts

@@ -0,0 +1,3 @@
+import { ExtendedActivity } from "../types/extended-activity";
+export declare function getTranformedActivityName(name: string): string;
+export declare function getNodeHtmlTemplate(data: ExtendedActivity): string;

package/contact-center/cc-script-editor/utils/node-mappings.d.ts

@@ -0,0 +1,54 @@
+import { ExtendedActivityType } from "../types/extended-activity";
+import { WxCCTemplatedActivityType } from "../types/wxcc-activity";
+export interface IconInfo {
+    iconSrc: string;
+    alt: string;
+}
+export interface ActivityDisplayType {
+    activityName: ExtendedActivityType;
+    value: ActivityDisplayTypeValue;
+    label: string;
+    icon: string;
+    group: string;
+}
+export interface CreatableActivityDisplayType extends ActivityDisplayType {
+    activityName: WxCCTemplatedActivityType;
+}
+export type ActivityDisplayTypeValue = 'condition-activity' | 'queue-contact' | 'ivr-menu' | 'blind-transfer' | 'wait-activity' | 'newphonecontact' | 'disconnect-contact' | 'play-message' | 'play-music' | 'unmapped' | 'business-hours' | 'set-variable' | 'end';
+/**
+ * Map of node icons based on display type or label
+ */
+export declare const ICON_MAP: {
+    [key in ActivityDisplayTypeValue]: string;
+};
+/**
+ * All available activity display types for node configuration
+ * Values match ICON_MAP keys exactly
+ */
+export declare const ACTIVITY_DISPLAY_TYPES: ActivityDisplayType[];
+export declare const CREATABLE_ACTIVITY_DISPLAY_TYPES: CreatableActivityDisplayType[];
+/**
+ * Get node icon information based on name or display type
+ * @param name - The node name or display type
+ * @returns Icon information with src and alt text
+ */
+export declare function getNodeIcon(name: string): IconInfo;
+/**
+ * Get node color class based on group
+ * @param group - The node group
+ * @returns CSS class name for node coloring
+ */
+export declare function getNodeColorClass(group: string): string;
+/**
+ * Get activity type label based on group
+ * @param group - The node group
+ * @returns Human-readable activity type label
+ */
+export declare function getActivityTypeLabel(group: string): string;
+/**
+ * Find activity display type by value
+ * @param value - The display type value
+ * @returns Display type or unmapped if not found
+ */
+export declare function getActivityDisplayTypeByValue(value: string): ActivityDisplayType;
+export declare function getCreatableActivityDisplayTypeByValue(value: string): CreatableActivityDisplayType;

package/contact-center/public-api.d.ts

@@ -1,3 +1,5 @@
 export * from './cc-readiness/cc-readiness.module';
+export * from './cc-script-editor/cc-script-editor.module';
 export * from './cc-readiness/widgets/summary-grid/summary-grid.component';
 export * from './cc-readiness/widgets/licences-requirement/licences-requirement.component';
+export * from './cc-script-editor/cc-script-editor.component';

package/esm2020/contact-center/cc-script-editor/cc-script-editor.component.mjs

@@ -0,0 +1,193 @@
+import { Component, Input } from "@angular/core";
+import { forkJoin, of, Subject, throwError } from "rxjs";
+import { finalize, mergeMap, takeUntil, tap } from "rxjs/operators";
+import irData from "./mock/data/QWC_ir.json";
+import * as i0 from "@angular/core";
+import * as i1 from "./services/wxcc-flow-api.service";
+import * as i2 from "./services/wxcc2graph.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/progress-spinner";
+import * as i5 from "./components/wxcc-flowchart/wxcc-flowchart.component";
+import * as i6 from "./components/wxcc-file-selection-bar/wxcc-file-selection-bar.component";
+import * as i7 from "./components/wxcc-actions-bar/wxcc-actions-bar.component";
+export class WxCCFlowchartPageComponent {
+    constructor(api, wxcc2graph) {
+        this.api = api;
+        this.wxcc2graph = wxcc2graph;
+        this.customerId = 0;
+        this.host = "";
+        this.token = "";
+        this.destroy$ = new Subject();
+        this.state = {
+            loading: true
+        };
+    }
+    ngOnInit() {
+        this.subscribeToCustomerChanges();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    init() {
+        this.loadMockFlowchart();
+    }
+    subscribeToCustomerChanges() {
+        // if (!this.customer) {
+        // this.customersService.customer$
+        //     .pipe(takeUntil(this.destroy$))
+        //     .subscribe((customer) => {
+        //         if (customer) {
+        this.init();
+        // }
+        // });
+        // } else {
+        //     this.init();
+        // }
+    }
+    loadMockFlowchart() {
+        const irDoc = irData;
+        this.state.irDoc = irDoc;
+        this.state.flowchart = this.wxcc2graph.parseWxCC(irDoc);
+        this.setLoading(false);
+    }
+    loadFileNames() {
+        // forkJoin([
+        //     this.uccxWorkflowApi.fetchFileNames(this.customerId)
+        //         .pipe(filter(fileNames => fileNames && fileNames.length > 0)),
+        //     this.contactCenterService.getCallFlowMigrationStatuses()
+        // ]).pipe(takeUntil(this.destroy$))
+        //     .subscribe(([fileNames, statuses]) => {
+        //         this.state.fileNames = fileNames;
+        //         this.state.uccxIp = fileNames[0].host;
+        //         this.state.selectedFileName = fileNames[0].fileName;
+        //         this.state.statuses = statuses.filter(status => status.uccxIp === this.state.uccxIp);
+        //         this.state.selectedFileStatus = this.getStatus(this.state.selectedFileName, this.state.uccxIp);
+        //         this.loadWxCCFlowData();
+        //     });
+    }
+    loadWxCCFlowData() {
+        forkJoin([
+            this.api.fetchWxCCFlowData(this.baseParams, this.state.selectedFileStatus),
+            this.api.fetchWxCCFlowDataIR(this.baseParams, this.state.selectedFileStatus),
+        ]).pipe(mergeMap(([nonIrDoc, irDoc]) => irDoc !== null ?
+            of({ nonIrDoc, irDoc }) :
+            throwError(() => new Error('No wxcc flow diagram available for this script'))), takeUntil(this.destroy$), finalize(() => this.setLoading(false))).subscribe({
+            next: ({ nonIrDoc, irDoc }) => {
+                this.wxcc2graph.setSourceDocuments(irDoc, nonIrDoc);
+                this.state.irDoc = irDoc;
+                this.state.nonIrDoc = nonIrDoc;
+                this.state.flowchart = this.wxcc2graph.parseWxCC(irDoc, nonIrDoc);
+            },
+            error: (error) => {
+                this.state.flowchart = null;
+                this.setError('No wxcc flow diagram available for this script');
+            }
+        });
+    }
+    onSave() {
+        this.setLoading(true);
+        forkJoin([
+            this.api.saveWxCCFlowData(this.baseParams, this.wxcc2graph.wxccNonIRJSON),
+            this.api.saveWxCCFlowDataIR(this.baseParams, this.wxcc2graph.wxccJSON)
+        ]).pipe(takeUntil(this.destroy$), finalize(() => this.setLoading(false)), tap(() => {
+            this.state.flowchart = this.wxcc2graph.parseWxCC(this.wxcc2graph.wxccJSON, this.wxcc2graph.wxccNonIRJSON);
+        })).subscribe({
+            next: ([regularResponse, irResponse]) => console.log('Flow data saved as DRAFT', regularResponse, irResponse),
+            error: (error) => console.error('Error while saving wxcc data: ', error)
+        });
+    }
+    onExportNonIr() {
+        if (!this.wxcc2graph.wxccNonIRJSON) {
+            console.error('Non-IR wxcc document is not loaded');
+            return;
+        }
+        const fileStem = (this.state.selectedFileName || 'wxcc-flow').replace(/\.[^/.]+$/, '');
+        const fileName = fileStem + '-non-ir.json';
+        const jsonContent = JSON.stringify(this.wxcc2graph.wxccNonIRJSON, null, 2);
+        const blob = new Blob([jsonContent], { type: 'application/json' });
+        const url = window.URL.createObjectURL(blob);
+        const anchor = document.createElement('a');
+        anchor.href = url;
+        anchor.download = fileName;
+        document.body.appendChild(anchor);
+        anchor.click();
+        document.body.removeChild(anchor);
+        window.URL.revokeObjectURL(url);
+    }
+    onReset() {
+        this.setLoading(true);
+        forkJoin([
+            this.api.resetWxCCFlowData(this.baseParams),
+            this.api.resetWxCCFlowDataIR(this.baseParams)
+        ]).pipe(takeUntil(this.destroy$), finalize(() => this.setLoading(false))).subscribe({
+            next: ([nonIrDoc, irDoc]) => {
+                this.wxcc2graph.setSourceDocuments(irDoc, nonIrDoc);
+                this.state.irDoc = irDoc;
+                this.state.nonIrDoc = nonIrDoc;
+                this.state.flowchart = this.wxcc2graph.parseWxCC(irDoc, nonIrDoc);
+                console.log('Flow data reset to original');
+            },
+            error: (error) => {
+                console.error('Error while resetting wxcc data: ', error);
+            }
+        });
+    }
+    onComplete() {
+        this.setLoading(true);
+        forkJoin([
+            this.api.completeWxCCFlowData(this.baseParams, this.wxcc2graph.wxccNonIRJSON),
+            this.api.completeWxCCFlowDataIR(this.baseParams, this.wxcc2graph.wxccJSON)
+        ]).pipe(takeUntil(this.destroy$), finalize(() => this.setLoading(false))).subscribe({
+            next: ([regularResponse, irResponse]) => {
+                console.log('Flow data saved as COMPLETED', regularResponse, irResponse);
+            },
+            error: (error) => {
+                console.error('Error while completing wxcc data: ', error);
+            }
+        });
+    }
+    onFileNameSelectionChange(item) {
+        const { fileName, host } = item;
+        this.state.selectedFileName = fileName;
+        this.state.uccxIp = host;
+        this.state.selectedFileStatus = this.getStatus(fileName, this.state.uccxIp);
+        this.setLoading(true);
+        this.loadWxCCFlowData();
+    }
+    getStatus(fileName, uccxIp) {
+        if (!this.state.statuses) {
+            throw Error('File status array is undefined');
+        }
+        const callFlowMigrationStatus = this.state.statuses.find(status => status.uccxIp === uccxIp && status.scriptName === fileName);
+        // if (callFlowMigrationStatus && callFlowMigrationStatus.status) {
+        //     return CALL_FLOW_MIGRATION_STATUSES_TO_SCRIPT_STATUS[callFlowMigrationStatus.status];
+        // }
+    }
+    setLoading(loading) {
+        this.state.loading = loading;
+    }
+    setError(error) {
+        this.state.errorMessage = error;
+    }
+    get baseParams() {
+        return {
+            customerId: this.customerId,
+            uccxIp: this.state.uccxIp || '',
+            fileName: this.state.selectedFileName || ''
+        };
+    }
+}
+WxCCFlowchartPageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WxCCFlowchartPageComponent, deps: [{ token: i1.WxCCAPIService }, { token: i2.WxCC2GraphService }], target: i0.ɵɵFactoryTarget.Component });
+WxCCFlowchartPageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: WxCCFlowchartPageComponent, selector: "cc-script-editor", inputs: { customerId: "customerId", host: "host", token: "token" }, ngImport: i0, template: "<div class=\"wxcc-flowchart-wrapper\">\r\n    <main class=\"content-box\">\r\n        <div class=\"wxcc-flowchart-main\">\r\n            <header class=\"wxcc-flowchart-header\">\r\n                <wxcc-file-selection-bar\r\n                    *ngIf=\"state.fileNames && state.fileNames.length\"\r\n                    [fileNames]=\"state.fileNames\"\r\n                    [selectedHost]=\"state.uccxIp\"\r\n                    [selectedFileName]=\"state.selectedFileName\"\r\n                    (fileNameSelectionChange)=\"onFileNameSelectionChange($event)\">\r\n                </wxcc-file-selection-bar>\r\n                <wxcc-actions-bar\r\n                    *ngIf=\"state.flowchart\"\r\n                    (save)=\"onSave()\"\r\n                    (reset)=\"onReset()\"\r\n                    (exportNonIr)=\"onExportNonIr()\"\r\n                    (complete)=\"onComplete()\">\r\n                </wxcc-actions-bar>\r\n            </header>\r\n            <ng-container *ngIf=\"!state.loading; else loadingTemplate\">\r\n                <wxcc-flowchart\r\n                    *ngIf=\"state.flowchart; else errorTemplate\"\r\n                    [flowchart]=\"state.flowchart\">\r\n                </wxcc-flowchart>\r\n            </ng-container>\r\n        </div>\r\n    </main>\r\n</div>\r\n\r\n<ng-template #loadingTemplate>\r\n    <div class=\"placeholder-wrapper\">\r\n        <mat-spinner diameter=\"40\"></mat-spinner>\r\n    </div>\r\n</ng-template>\r\n\r\n<ng-template #errorTemplate>\r\n    <div class=\"placeholder-wrapper\">\r\n        Error loading script\r\n    </div>\r\n</ng-template>\r\n", styles: [":host{display:block;width:100%;height:100%}.wxcc-flowchart-wrapper{width:100%;height:100%;display:flex;flex-direction:column}.wxcc-flowchart-wrapper .content-box{flex:1;display:flex;flex-direction:column;overflow:hidden}.wxcc-flowchart-wrapper .wxcc-flowchart-main{flex:1;display:flex;flex-direction:column;gap:.5rem;overflow:hidden}.wxcc-flowchart-wrapper .wxcc-flowchart-main .wxcc-flowchart-header{display:flex;align-items:center;justify-content:space-between;flex-shrink:0}.wxcc-flowchart-wrapper .wxcc-flowchart-main .placeholder-wrapper{display:flex;flex-direction:column;align-items:center;justify-content:center;height:100%}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "diameter", "strokeWidth", "mode", "value"], exportAs: ["matProgressSpinner"] }, { kind: "component", type: i5.WxCCFlowchartComponent, selector: "wxcc-flowchart", inputs: ["flowchart"] }, { kind: "component", type: i6.WxCCFileSelectionBarComponent, selector: "wxcc-file-selection-bar", inputs: ["fileNames", "selectedFileName", "selectedHost"], outputs: ["fileNameSelectionChange"] }, { kind: "component", type: i7.WxCCActionsBarComponent, selector: "wxcc-actions-bar", outputs: ["save", "reset", "complete", "exportNonIr"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WxCCFlowchartPageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cc-script-editor', template: "<div class=\"wxcc-flowchart-wrapper\">\r\n    <main class=\"content-box\">\r\n        <div class=\"wxcc-flowchart-main\">\r\n            <header class=\"wxcc-flowchart-header\">\r\n                <wxcc-file-selection-bar\r\n                    *ngIf=\"state.fileNames && state.fileNames.length\"\r\n                    [fileNames]=\"state.fileNames\"\r\n                    [selectedHost]=\"state.uccxIp\"\r\n                    [selectedFileName]=\"state.selectedFileName\"\r\n                    (fileNameSelectionChange)=\"onFileNameSelectionChange($event)\">\r\n                </wxcc-file-selection-bar>\r\n                <wxcc-actions-bar\r\n                    *ngIf=\"state.flowchart\"\r\n                    (save)=\"onSave()\"\r\n                    (reset)=\"onReset()\"\r\n                    (exportNonIr)=\"onExportNonIr()\"\r\n                    (complete)=\"onComplete()\">\r\n                </wxcc-actions-bar>\r\n            </header>\r\n            <ng-container *ngIf=\"!state.loading; else loadingTemplate\">\r\n                <wxcc-flowchart\r\n                    *ngIf=\"state.flowchart; else errorTemplate\"\r\n                    [flowchart]=\"state.flowchart\">\r\n                </wxcc-flowchart>\r\n            </ng-container>\r\n        </div>\r\n    </main>\r\n</div>\r\n\r\n<ng-template #loadingTemplate>\r\n    <div class=\"placeholder-wrapper\">\r\n        <mat-spinner diameter=\"40\"></mat-spinner>\r\n    </div>\r\n</ng-template>\r\n\r\n<ng-template #errorTemplate>\r\n    <div class=\"placeholder-wrapper\">\r\n        Error loading script\r\n    </div>\r\n</ng-template>\r\n", styles: [":host{display:block;width:100%;height:100%}.wxcc-flowchart-wrapper{width:100%;height:100%;display:flex;flex-direction:column}.wxcc-flowchart-wrapper .content-box{flex:1;display:flex;flex-direction:column;overflow:hidden}.wxcc-flowchart-wrapper .wxcc-flowchart-main{flex:1;display:flex;flex-direction:column;gap:.5rem;overflow:hidden}.wxcc-flowchart-wrapper .wxcc-flowchart-main .wxcc-flowchart-header{display:flex;align-items:center;justify-content:space-between;flex-shrink:0}.wxcc-flowchart-wrapper .wxcc-flowchart-main .placeholder-wrapper{display:flex;flex-direction:column;align-items:center;justify-content:center;height:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.WxCCAPIService }, { type: i2.WxCC2GraphService }]; }, propDecorators: { customerId: [{
+                type: Input
+            }], host: [{
+                type: Input
+            }], token: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cc-script-editor.component.js","sourceRoot":"","sources":["../../../../../../projects/tuki/widgets/contact-center/cc-script-editor/cc-script-editor.component.ts","../../../../../../projects/tuki/widgets/contact-center/cc-script-editor/cc-script-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnDestroy, OnInit } from \"@angular/core\";\r\nimport { WxCCAPIService } from \"./services/wxcc-flow-api.service\";\r\nimport { forkJoin, of, Subject, throwError } from \"rxjs\";\r\nimport { IWxCCFlowchart, IWxCCJSON, IWxCCNonIRJSON } from \"./types/wxcc\";\r\nimport { WxCC2GraphService } from \"./services/wxcc2graph.service\";\r\nimport { filter, finalize, mergeMap, takeUntil, tap } from \"rxjs/operators\";\r\nimport irData from \"./mock/data/QWC_ir.json\";\r\n// import { UCCXWorkflowAPIService } from \"../../uccx-workflow/services/uccx-workflow-api.service\";\r\n// import { CustomersService } from \"../../../services/customers.service\";\r\n// import { ContactCenterService } from \"../contact-center.service\";\r\n// import {\r\n//     CALL_FLOW_MIGRATION_STATUSES_TO_SCRIPT_STATUS,\r\n//     CallFlowMigrationStatus\r\n// } from \"../interfaces/call-flow-migration-status.interface\";\r\nimport { FileState } from \"./constants/wxcc-api.constants\";\r\n\r\ntype WxCCFlowchartState = {\r\n    fileNames: { fileName: string; host: string }[];\r\n    uccxIp: string;\r\n    selectedFileName: string;\r\n    selectedFileStatus: FileState;\r\n    loading: boolean;\r\n    flowchart: IWxCCFlowchart | null;\r\n    irDoc: IWxCCJSON;\r\n    nonIrDoc: IWxCCNonIRJSON;\r\n    errorMessage: string;\r\n    statuses: any[];\r\n};\r\n\r\n@Component({\r\n    selector: 'cc-script-editor',\r\n    templateUrl: './cc-script-editor.component.html',\r\n    styleUrls: ['./cc-script-editor.component.scss']\r\n})\r\nexport class WxCCFlowchartPageComponent implements OnInit, OnDestroy {\r\n    @Input() customerId = 0;\r\n    @Input() host = \"\";\r\n    @Input() token = \"\";\r\n\r\n    private readonly destroy$ = new Subject<void>();\r\n\r\n    readonly state: WxCCFlowchartState = {\r\n        loading: true\r\n    } as any;\r\n\r\n    constructor(\r\n        private readonly api: WxCCAPIService,\r\n        private readonly wxcc2graph: WxCC2GraphService,\r\n        // private readonly customersService: CustomersService,\r\n        // private readonly uccxWorkflowApi: UCCXWorkflowAPIService,\r\n        // private readonly contactCenterService: ContactCenterService\r\n    ) { }\r\n\r\n    ngOnInit(): void {\r\n        this.subscribeToCustomerChanges();\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this.destroy$.next();\r\n        this.destroy$.complete();\r\n    }\r\n\r\n    private init(): void {\r\n        this.loadMockFlowchart();\r\n    }\r\n\r\n    private subscribeToCustomerChanges(): void {\r\n        // if (!this.customer) {\r\n        // this.customersService.customer$\r\n        //     .pipe(takeUntil(this.destroy$))\r\n        //     .subscribe((customer) => {\r\n        //         if (customer) {\r\n        this.init();\r\n        // }\r\n        // });\r\n        // } else {\r\n        //     this.init();\r\n        // }\r\n    }\r\n\r\n    private loadMockFlowchart(): void {\r\n        const irDoc = irData as unknown as IWxCCJSON;\r\n        this.state.irDoc = irDoc;\r\n        this.state.flowchart = this.wxcc2graph.parseWxCC(irDoc);\r\n        this.setLoading(false);\r\n    }\r\n\r\n    private loadFileNames(): void {\r\n        // forkJoin([\r\n        //     this.uccxWorkflowApi.fetchFileNames(this.customerId)\r\n        //         .pipe(filter(fileNames => fileNames && fileNames.length > 0)),\r\n        //     this.contactCenterService.getCallFlowMigrationStatuses()\r\n        // ]).pipe(takeUntil(this.destroy$))\r\n        //     .subscribe(([fileNames, statuses]) => {\r\n        //         this.state.fileNames = fileNames;\r\n        //         this.state.uccxIp = fileNames[0].host;\r\n        //         this.state.selectedFileName = fileNames[0].fileName;\r\n\r\n        //         this.state.statuses = statuses.filter(status => status.uccxIp === this.state.uccxIp);\r\n        //         this.state.selectedFileStatus = this.getStatus(this.state.selectedFileName, this.state.uccxIp);\r\n\r\n        //         this.loadWxCCFlowData();\r\n        //     });\r\n    }\r\n\r\n    private loadWxCCFlowData(): void {\r\n        forkJoin([\r\n            this.api.fetchWxCCFlowData(this.baseParams, this.state.selectedFileStatus),\r\n            this.api.fetchWxCCFlowDataIR(this.baseParams, this.state.selectedFileStatus),\r\n        ]).pipe(\r\n            mergeMap(([nonIrDoc, irDoc]) =>\r\n                irDoc !== null ?\r\n                    of({ nonIrDoc, irDoc }) :\r\n                    throwError(() => new Error('No wxcc flow diagram available for this script'))\r\n            ),\r\n            takeUntil(this.destroy$),\r\n            finalize(() => this.setLoading(false))\r\n        ).subscribe({\r\n            next: ({ nonIrDoc, irDoc }) => {\r\n                this.wxcc2graph.setSourceDocuments(irDoc, nonIrDoc);\r\n                this.state.irDoc = irDoc;\r\n                this.state.nonIrDoc = nonIrDoc;\r\n                this.state.flowchart = this.wxcc2graph.parseWxCC(irDoc, nonIrDoc);\r\n            },\r\n            error: (error) => {\r\n                this.state.flowchart = null;\r\n                this.setError('No wxcc flow diagram available for this script');\r\n            }\r\n        });\r\n    }\r\n\r\n    onSave() {\r\n        this.setLoading(true);\r\n\r\n        forkJoin([\r\n            this.api.saveWxCCFlowData(this.baseParams, this.wxcc2graph.wxccNonIRJSON),\r\n            this.api.saveWxCCFlowDataIR(this.baseParams, this.wxcc2graph.wxccJSON)\r\n        ]).pipe(\r\n            takeUntil(this.destroy$),\r\n            finalize(() => this.setLoading(false)),\r\n            tap(() => {\r\n                this.state.flowchart = this.wxcc2graph.parseWxCC(\r\n                    this.wxcc2graph.wxccJSON,\r\n                    this.wxcc2graph.wxccNonIRJSON\r\n                );\r\n            })\r\n        ).subscribe({\r\n            next: ([regularResponse, irResponse]) => console.log('Flow data saved as DRAFT', regularResponse, irResponse),\r\n            error: (error) => console.error('Error while saving wxcc data: ', error)\r\n        });\r\n    }\r\n\r\n    onExportNonIr() {\r\n        if (!this.wxcc2graph.wxccNonIRJSON) {\r\n            console.error('Non-IR wxcc document is not loaded');\r\n            return;\r\n        }\r\n\r\n        const fileStem = (this.state.selectedFileName || 'wxcc-flow').replace(/\\.[^/.]+$/, '');\r\n        const fileName = fileStem + '-non-ir.json';\r\n        const jsonContent = JSON.stringify(this.wxcc2graph.wxccNonIRJSON, null, 2);\r\n        const blob = new Blob([jsonContent], { type: 'application/json' });\r\n        const url = window.URL.createObjectURL(blob);\r\n\r\n        const anchor = document.createElement('a');\r\n        anchor.href = url;\r\n        anchor.download = fileName;\r\n        document.body.appendChild(anchor);\r\n        anchor.click();\r\n        document.body.removeChild(anchor);\r\n\r\n        window.URL.revokeObjectURL(url);\r\n    }\r\n\r\n    onReset() {\r\n        this.setLoading(true);\r\n        forkJoin([\r\n            this.api.resetWxCCFlowData(this.baseParams),\r\n            this.api.resetWxCCFlowDataIR(this.baseParams)\r\n        ]).pipe(\r\n            takeUntil(this.destroy$),\r\n            finalize(() => this.setLoading(false))\r\n        ).subscribe({\r\n            next: ([nonIrDoc, irDoc]) => {\r\n                this.wxcc2graph.setSourceDocuments(irDoc, nonIrDoc);\r\n                this.state.irDoc = irDoc;\r\n                this.state.nonIrDoc = nonIrDoc;\r\n                this.state.flowchart = this.wxcc2graph.parseWxCC(irDoc, nonIrDoc);\r\n                console.log('Flow data reset to original');\r\n            },\r\n            error: (error) => {\r\n                console.error('Error while resetting wxcc data: ', error);\r\n            }\r\n        });\r\n    }\r\n\r\n    onComplete() {\r\n        this.setLoading(true);\r\n\r\n        forkJoin([\r\n            this.api.completeWxCCFlowData(this.baseParams, this.wxcc2graph.wxccNonIRJSON),\r\n            this.api.completeWxCCFlowDataIR(this.baseParams, this.wxcc2graph.wxccJSON)\r\n        ]).pipe(\r\n            takeUntil(this.destroy$),\r\n            finalize(() => this.setLoading(false))\r\n        ).subscribe({\r\n            next: ([regularResponse, irResponse]) => {\r\n                console.log('Flow data saved as COMPLETED', regularResponse, irResponse);\r\n            },\r\n            error: (error) => {\r\n                console.error('Error while completing wxcc data: ', error);\r\n            }\r\n        });\r\n    }\r\n\r\n    onFileNameSelectionChange(item: { fileName: string, host: string }) {\r\n        const { fileName, host } = item;\r\n        this.state.selectedFileName = fileName;\r\n        this.state.uccxIp = host;\r\n\r\n        this.state.selectedFileStatus = this.getStatus(fileName, this.state.uccxIp);\r\n        this.setLoading(true);\r\n        this.loadWxCCFlowData();\r\n    }\r\n\r\n    getStatus(fileName: string, uccxIp: string): any {\r\n        if (!this.state.statuses) {\r\n            throw Error('File status array is undefined');\r\n        }\r\n\r\n        const callFlowMigrationStatus = this.state.statuses.find(\r\n            status => status.uccxIp === uccxIp && status.scriptName === fileName\r\n        );\r\n\r\n        // if (callFlowMigrationStatus && callFlowMigrationStatus.status) {\r\n        //     return CALL_FLOW_MIGRATION_STATUSES_TO_SCRIPT_STATUS[callFlowMigrationStatus.status];\r\n        // }\r\n    }\r\n\r\n    setLoading(loading: boolean): void {\r\n        this.state.loading = loading;\r\n    }\r\n\r\n    setError(error: string): void {\r\n        this.state.errorMessage = error;\r\n    }\r\n\r\n    private get baseParams() {\r\n        return {\r\n            customerId: this.customerId,\r\n            uccxIp: this.state.uccxIp || '',\r\n            fileName: this.state.selectedFileName || ''\r\n        };\r\n    }\r\n\r\n    // private get customer() {\r\n    //     return this.customersService.currentCustomer;\r\n    // }\r\n\r\n    // private get customerId() {\r\n    //     return this.customer.id;\r\n    // }\r\n}\r\n","<div class=\"wxcc-flowchart-wrapper\">\r\n    <main class=\"content-box\">\r\n        <div class=\"wxcc-flowchart-main\">\r\n            <header class=\"wxcc-flowchart-header\">\r\n                <wxcc-file-selection-bar\r\n                    *ngIf=\"state.fileNames && state.fileNames.length\"\r\n                    [fileNames]=\"state.fileNames\"\r\n                    [selectedHost]=\"state.uccxIp\"\r\n                    [selectedFileName]=\"state.selectedFileName\"\r\n                    (fileNameSelectionChange)=\"onFileNameSelectionChange($event)\">\r\n                </wxcc-file-selection-bar>\r\n                <wxcc-actions-bar\r\n                    *ngIf=\"state.flowchart\"\r\n                    (save)=\"onSave()\"\r\n                    (reset)=\"onReset()\"\r\n                    (exportNonIr)=\"onExportNonIr()\"\r\n                    (complete)=\"onComplete()\">\r\n                </wxcc-actions-bar>\r\n            </header>\r\n            <ng-container *ngIf=\"!state.loading; else loadingTemplate\">\r\n                <wxcc-flowchart\r\n                    *ngIf=\"state.flowchart; else errorTemplate\"\r\n                    [flowchart]=\"state.flowchart\">\r\n                </wxcc-flowchart>\r\n            </ng-container>\r\n        </div>\r\n    </main>\r\n</div>\r\n\r\n<ng-template #loadingTemplate>\r\n    <div class=\"placeholder-wrapper\">\r\n        <mat-spinner diameter=\"40\"></mat-spinner>\r\n    </div>\r\n</ng-template>\r\n\r\n<ng-template #errorTemplate>\r\n    <div class=\"placeholder-wrapper\">\r\n        Error loading script\r\n    </div>\r\n</ng-template>\r\n"]}

package/esm2020/contact-center/cc-script-editor/cc-script-editor.module.mjs

@@ -0,0 +1,83 @@
+import { NgModule } from "@angular/core";
+import { WxCCFlowchartComponent } from "./components/wxcc-flowchart/wxcc-flowchart.component";
+import { NodeDetailsSidebarComponent } from "./components/node-details-sidebar/node-details-sidebar.component";
+import { NodeActionToolbarComponent } from "./components/node-action-toolbar/node-action-toolbar.component";
+import { CommonModule } from "@angular/common";
+import { FormsModule } from "@angular/forms";
+import { WxCCAPIService } from "./services/wxcc-flow-api.service";
+import { WxCC2GraphService } from "./services/wxcc2graph.service";
+import { WxCCActivityManageService } from "./services/wxcc-activity-manage.service";
+import { WxCCActivityCreationService } from "./services/wxcc-activity-creation.service";
+import { WxCCFileSelectionBarComponent } from "./components/wxcc-file-selection-bar/wxcc-file-selection-bar.component";
+import { WxCCActionsBarComponent } from "./components/wxcc-actions-bar/wxcc-actions-bar.component";
+import { AddNodeDialogComponent } from "./components/dialogs/add-node-dialog/add-node-dialog.component";
+import { LinkNodeDialogComponent } from "./components/dialogs/link-node-dialog/link-node-dialog.component";
+import { NodeSearchPanelComponent } from "./components/node-search-panel/node-search-panel.component";
+import { WxCCFlowchartPageComponent } from "./cc-script-editor.component";
+import { SharedModule } from "../shared/shared.module";
+import { MaterialModule } from "../shared/material.module";
+import { FloatingToolbarModule } from "./components/floating-toolbar/floating-toolbar.module";
+import * as i0 from "@angular/core";
+export class WxCCFlowchartModule {
+}
+WxCCFlowchartModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WxCCFlowchartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+WxCCFlowchartModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: WxCCFlowchartModule, declarations: [WxCCFlowchartPageComponent,
+        WxCCFlowchartComponent,
+        NodeDetailsSidebarComponent,
+        NodeActionToolbarComponent,
+        LinkNodeDialogComponent,
+        WxCCFileSelectionBarComponent,
+        AddNodeDialogComponent,
+        WxCCActionsBarComponent,
+        NodeSearchPanelComponent], imports: [CommonModule,
+        FormsModule,
+        SharedModule,
+        MaterialModule,
+        FloatingToolbarModule], exports: [WxCCFlowchartPageComponent] });
+WxCCFlowchartModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WxCCFlowchartModule, providers: [
+        WxCCAPIService,
+        WxCC2GraphService,
+        WxCCActivityManageService,
+        WxCCActivityCreationService
+    ], imports: [CommonModule,
+        FormsModule,
+        SharedModule,
+        MaterialModule,
+        FloatingToolbarModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WxCCFlowchartModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        WxCCFlowchartPageComponent,
+                        WxCCFlowchartComponent,
+                        NodeDetailsSidebarComponent,
+                        NodeActionToolbarComponent,
+                        LinkNodeDialogComponent,
+                        WxCCFileSelectionBarComponent,
+                        AddNodeDialogComponent,
+                        WxCCActionsBarComponent,
+                        NodeSearchPanelComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        SharedModule,
+                        MaterialModule,
+                        FloatingToolbarModule
+                    ],
+                    exports: [
+                        WxCCFlowchartPageComponent
+                    ],
+                    providers: [
+                        WxCCAPIService,
+                        WxCC2GraphService,
+                        WxCCActivityManageService,
+                        WxCCActivityCreationService
+                    ],
+                    entryComponents: [
+                        AddNodeDialogComponent,
+                        LinkNodeDialogComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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