@tuki-io/tuki-widgets 0.0.176 → 0.0.178

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

@@ -0,0 +1,96 @@
+interface FlowType {
+    eventSourceName: string;
+    eventSpecificationName: string;
+    eventClassificationId: string;
+    eventClassificationName: string;
+    eventSpecificationId: string;
+    eventSourceId: string;
+}
+interface Prompt {
+    type: string;
+    value: string;
+    name: string;
+}
+interface SetVariableArrayItem {
+    setTo: string;
+    id: string;
+    literal_invalid_error: boolean;
+}
+export type WxCCActivityType = 'NewPhoneContact' | 'end' | 'disconnect-contact' | 'queue-contact' | 'play-music' | 'play-message' | 'wait-activity' | 'set-variable' | 'ivr-menu' | 'ivr-collectdigits' | 'condition-activity' | 'business-hours' | 'blind-transfer';
+interface WxCCActivityBase<TProps, TActivity extends WxCCActivityType = WxCCActivityType> {
+    id: string;
+    name: string;
+    type: TActivity;
+    group: string;
+    properties: TProps;
+}
+interface BaseActivityProperties<TName extends WxCCActivityType> {
+    activityName: TName;
+    activityId: string;
+    _renderRequestTimestamp: number;
+}
+interface MediaBaseProps<TName extends WxCCActivityType> extends BaseActivityProperties<TName> {
+    connector_name: string | null;
+    name: string;
+    toggle: boolean;
+    prompts: Prompt[];
+    volumeGainDb: number;
+    voiceLanguage_name: string | null;
+    promptsTts: unknown;
+    connector: unknown;
+    speakingRate: number;
+    toggleLanguage: unknown;
+    voiceLanguage: unknown;
+    flowDecryptAccess: boolean;
+    'connector:name': string | null;
+    'voiceLanguage:name': unknown;
+}
+type NewPhoneContactProps = BaseActivityProperties<'NewPhoneContact'> & {
+    name: string;
+    event: string;
+    flowType: FlowType;
+};
+type PlayMessageProps = MediaBaseProps<'play-message'>;
+type PlayMusicProps = MediaBaseProps<'play-music'>;
+type IvrMenuProps = MediaBaseProps<'ivr-menu'> & {
+    menuLinks: string[];
+    'menuLinks:input': string[];
+    menuLinks_input: string[];
+    entryTimeout: number;
+    interruptible: boolean;
+};
+type SetVariableProps = BaseActivityProperties<'set-variable'> & {
+    setTo: string;
+    name: string;
+    literal_invalid_error: boolean;
+    setVariablesArray: SetVariableArrayItem[];
+    flowDecryptAccess: boolean;
+};
+type BlindTransferProps = BaseActivityProperties<'blind-transfer'> & {
+    name: string;
+    transfertodn: string;
+    transfertodn_radioName: string;
+    'transfertodn:radioName': string;
+    customAttributes: Record<string, unknown>;
+    flowDecryptAccess: boolean;
+};
+type BusinessHoursProps = BaseActivityProperties<'business-hours'>;
+type NewPhoneContactActivity = WxCCActivityBase<NewPhoneContactProps, 'NewPhoneContact'>;
+type PlayMessageActivity = WxCCActivityBase<PlayMessageProps, 'play-message'>;
+type PlayMusicActivity = WxCCActivityBase<PlayMusicProps, 'play-music'>;
+type IvrMenuActivity = WxCCActivityBase<IvrMenuProps, 'ivr-menu'>;
+type SetVariableActivity = WxCCActivityBase<SetVariableProps, 'set-variable'>;
+type BlindTransferActivity = WxCCActivityBase<BlindTransferProps, 'blind-transfer'>;
+type BusinessHoursActivity = WxCCActivityBase<BusinessHoursProps, 'business-hours'>;
+export type WxCCActivity = NewPhoneContactActivity | PlayMessageActivity | PlayMusicActivity | IvrMenuActivity | SetVariableActivity | BlindTransferActivity | BusinessHoursActivity;
+export type WxCCActivityMap = {
+    NewPhoneContact: NewPhoneContactActivity;
+    'play-message': PlayMessageActivity;
+    'play-music': PlayMusicActivity;
+    'ivr-menu': IvrMenuActivity;
+    'set-variable': SetVariableActivity;
+    'blind-transfer': BlindTransferActivity;
+    'business-hours': BusinessHoursActivity;
+};
+export type WxCCTemplatedActivityType = keyof WxCCActivityMap;
+export {};

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/contact-center/shared/material.module.d.ts

@@ -8,8 +8,9 @@ import * as i6 from "@angular/material/icon";
 import * as i7 from "@angular/material/form-field";
 import * as i8 from "@angular/material/input";
 import * as i9 from "@angular/material/select";
+import * as i10 from "@angular/material/progress-spinner";
 export declare class MaterialModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<MaterialModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<MaterialModule, never, [typeof i1.MatProgressBarModule, typeof i2.MatTooltipModule, typeof i3.MatTableModule, typeof i4.MatCheckboxModule, typeof i5.MatButtonModule, typeof i6.MatIconModule, typeof i7.MatFormFieldModule, typeof i8.MatInputModule, typeof i9.MatSelectModule], [typeof i1.MatProgressBarModule, typeof i2.MatTooltipModule, typeof i3.MatTableModule, typeof i4.MatCheckboxModule, typeof i5.MatButtonModule, typeof i6.MatIconModule, typeof i7.MatFormFieldModule, typeof i8.MatInputModule, typeof i9.MatSelectModule]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MaterialModule, never, [typeof i1.MatProgressBarModule, typeof i2.MatTooltipModule, typeof i3.MatTableModule, typeof i4.MatCheckboxModule, typeof i5.MatButtonModule, typeof i6.MatIconModule, typeof i7.MatFormFieldModule, typeof i8.MatInputModule, typeof i9.MatSelectModule], [typeof i1.MatProgressBarModule, typeof i2.MatTooltipModule, typeof i3.MatTableModule, typeof i4.MatCheckboxModule, typeof i5.MatButtonModule, typeof i6.MatIconModule, typeof i7.MatFormFieldModule, typeof i8.MatInputModule, typeof i9.MatSelectModule, typeof i10.MatProgressSpinnerModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<MaterialModule>;
 }

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"]}