qms-angular 1.0.86 → 1.0.87

package/esm2015/lib/qms-ckeditor-components/components/qms-ckeditor-flowchart/qms-ckeditor-flowchart.component.js

@@ -0,0 +1,317 @@
+import { __awaiter } from "tslib";
+import { Component, ElementRef, HostListener, Inject } from "@angular/core";
+import { MatDialog, MatDialogRef, MAT_DIALOG_DATA } from "@angular/material/dialog";
+import { takeUntil } from "rxjs/operators";
+import { TranslateLibraryService } from "../../../services/translation-registry.service";
+import { CKEditorEventConst } from "../../common/constants/ckeditorEvent.constant";
+import { FlowChartConst } from "../../common/constants/ckeditorFlowchart.const";
+import { KeyboardService } from "../../common/flowchart/service/keyboard-service";
+import RappidService from '../../common/flowchart/service/kitchensink-service';
+import { ThemePicker } from "../../common/flowchart/themes/theme-picker";
+import guidHelper from "../../common/helper/guidHelper";
+import { QMSCKEditorDialogData } from "../../common/models/qms-ckeditor-dialog.model";
+import { QMSCKEditorFlowchart } from "../../common/models/qms-ckeditor-flowchart.model";
+import { QMSCKEditorSaveAsTemplate } from "../../common/models/qms-ckeditor-save-as-template.model";
+import { QMSCKEditorConfirmComponent } from "../../common/module/confirm/qms-ckeditor-confirm.component";
+import { QMSCKEditorToastService } from "../../common/toast/qms-ckeditor-toast.service";
+import { QMSCKEditorBaseComponent } from "../../qms-ckeditor-base.component";
+import { QMSCKEditorFlowchartService } from "../../services/qms-ckeditor-flowchart.service";
+import { SaveTemplateComponent } from "../qms-ckeditor-bpmn/save-template/save-template.component";
+export class QMSCKEditorFlowchartComponent extends QMSCKEditorBaseComponent {
+    constructor(dialog, element, translate, flowchartService, dialogRef, data) {
+        super();
+        this.dialog = dialog;
+        this.element = element;
+        this.translate = translate;
+        this.flowchartService = flowchartService;
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.jsonContent = '';
+        this.id = '';
+        this.flowchart = new QMSCKEditorFlowchart();
+        this.flowchartTemplates = [];
+        this.id = data;
+    }
+    onMessage(event) {
+        if (event.data === FlowChartConst.KS_CHANGE_TEMPLATE) {
+            this.onChangeTemplate();
+        }
+        else if (event.data === FlowChartConst.KS_DELETE_TEMPLATE) {
+            this.onDeleteTemplate(this.LANG.BPMN.DELETE_TEMPLATE, this.LANG.QMSCKEDITOR_MESSAGE.CONFIRM_DELETE_TEMPLATE);
+        }
+        else if (event.data === FlowChartConst.MUST_SELECT_TEMPLATE) {
+            this.showInfoMessage(this.LANG.BPMN.SELECT_TEMPLATE, this.LANG.BPMN.SELECT_TEMPLATE_INFORMATION);
+        }
+        else if (event.data === FlowChartConst.KS_SAVE_AS_TEMPLATE) {
+            this.onSaveAsTemplate();
+        }
+        else if (event.data === FlowChartConst.KS_RESET_TEMPLATE) {
+            this.onResetTemplate();
+        }
+    }
+    ngOnInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.translate.getLanguageSubject$.pipe(takeUntil(this.ngUnsubcribe)).subscribe((res) => {
+                if (res) {
+                    this.LANG = this.translate.getObjectLang(res);
+                }
+            });
+            if (this.id) {
+                this.jsonContent = yield this.getJsonContent(this.id);
+            }
+            this.rappid = new RappidService(this.element.nativeElement, new KeyboardService(), this.LANG);
+            this.rappid.startRappid();
+            const themePicker = new ThemePicker({ mainView: this.rappid });
+            themePicker.render().$el.appendTo(document.getElementById('themepicker'));
+            if (this.jsonContent) {
+                this.rappid.graph.fromJSON(JSON.parse(this.jsonContent));
+            }
+        });
+    }
+    ngAfterViewInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.flowchartTemplates = yield this.getTemplates();
+            this.initializeTemplates(this.flowchartTemplates);
+        });
+    }
+    getJsonContent(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                this.flowchartService
+                    .getFlowchartById(id)
+                    .pipe(takeUntil(this.ngUnsubcribe))
+                    .subscribe((result) => {
+                    if (result) {
+                        resolve(result.jsonContent);
+                    }
+                });
+            });
+        });
+    }
+    getTemplates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                this.flowchartService
+                    .flowchartGetTemplates()
+                    .pipe(takeUntil(this.ngUnsubcribe))
+                    .subscribe((result) => {
+                    resolve(result);
+                });
+            });
+        });
+    }
+    initializeTemplates(templates) {
+        if (templates) {
+            this.toolbarConfig = this.rappid.toolbar;
+            const arrSelect = this.toolbarConfig.tools.filter((item) => {
+                return item.type === 'select-box';
+            });
+            if (arrSelect && arrSelect[0]) {
+                templates.forEach((item) => {
+                    const option = {
+                        index: item.index,
+                        content: item.templateName,
+                        flowChartId: item.id,
+                        name: item.templateName,
+                        jsonContent: item.jsonContent,
+                        selected: false
+                    };
+                    const index = arrSelect[0].options.findIndex((x) => {
+                        return x.index === option.index;
+                    });
+                    if (index < 0) {
+                        arrSelect[0].options.push(option);
+                    }
+                });
+            }
+        }
+    }
+    addItem2Template(template) {
+        this.toolbarConfig = this.rappid.toolbar;
+        const arrSelect = this.toolbarConfig.tools.filter((item) => {
+            return item.type === 'select-box';
+        });
+        if (arrSelect) {
+            const option = {
+                index: 1,
+                content: template.templateName,
+                flowChartId: template.id,
+                name: template.templateName,
+                jsonContent: template.jsonContent,
+                selected: false
+            };
+            arrSelect[0].options.push(option);
+        }
+    }
+    removeSelectedValue(flowChartId) {
+        this.toolbarConfig = this.rappid.toolbar;
+        const arrSelect = this.toolbarConfig.tools.filter((item) => {
+            return item.type === 'select-box';
+        });
+        if (arrSelect) {
+            arrSelect[0].options.splice(arrSelect[0].options.findIndex((i) => {
+                return i.flowChartId === flowChartId;
+            }), 1);
+        }
+    }
+    setDefaultSelectedValue() {
+        this.toolbarConfig = this.rappid.toolbar;
+        const arrSelect = this.toolbarConfig.tools.filter((item) => {
+            return item.type === 'select-box';
+        });
+        if (arrSelect) {
+            arrSelect[0].options[0].selected = true;
+            const list = document.getElementsByClassName(`select-box-selection`)[0];
+            list.getElementsByClassName(`select-box-option-content`)[0].innerHTML = FlowChartConst.SELECT_TEMPLATE;
+        }
+    }
+    saveImageContent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                const jsonContent = this.rappid.getJsonContent();
+                this.flowchart = {
+                    id: this.id ? this.id : guidHelper.empty,
+                    jsonContent: jsonContent,
+                    isTemplate: false,
+                    templateName: ''
+                };
+                this.flowchartService
+                    .flowchartModifying(this.flowchart)
+                    .pipe(takeUntil(this.ngUnsubcribe))
+                    .subscribe((result) => {
+                    if (result) {
+                        resolve(result);
+                    }
+                });
+            });
+        });
+    }
+    onInsertImage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = yield this.saveImageContent();
+            const imageContent = yield this.rappid.getImageContent();
+            const result = { key: `${CKEditorEventConst.QMSCK_FLOWCHART}#${id}`, values: imageContent };
+            this.dialogRef.close(result);
+        });
+    }
+    onChangeTemplate() {
+        const jsonTemplate = window[FlowChartConst.KS_SELECTED_JSONCONTENT] ? window[FlowChartConst.KS_SELECTED_JSONCONTENT] : '';
+        if (!window[FlowChartConst.KS_IS_SELECTED_TEMPLATE]) {
+            window[FlowChartConst.KS_ORG_JSONCONTENT] = JSON.stringify(this.rappid.graph.toJSON());
+            window[FlowChartConst.KS_IS_SELECTED_TEMPLATE] = true;
+        }
+        if (jsonTemplate) {
+            this.rappid.graph.fromJSON(JSON.parse(jsonTemplate));
+        }
+    }
+    onDeleteTemplate(title, content) {
+        const data = new QMSCKEditorDialogData();
+        data.title = title;
+        data.content = content;
+        const dialogRef = this.dialog.open(QMSCKEditorConfirmComponent, {
+            width: '500px',
+            minHeight: '175px',
+            data
+        });
+        dialogRef
+            .afterClosed()
+            .pipe(takeUntil(this.ngUnsubcribe))
+            .subscribe((result) => {
+            if (result) {
+                const id = window[FlowChartConst.KS_SELECTED_FLOWCHART_ID];
+                this.flowchartService
+                    .flowchartDeleteTemplate(id)
+                    .pipe(takeUntil(this.ngUnsubcribe))
+                    .subscribe((result) => {
+                    if (result) {
+                        this.removeSelectedValue(id);
+                        this.setDefaultSelectedValue();
+                        window[FlowChartConst.KS_IS_SELECTED_TEMPLATE] = false;
+                        QMSCKEditorToastService.success(this.LANG.QMSCKEDITOR.DELETED);
+                    }
+                    else {
+                        QMSCKEditorToastService.error(this.LANG.QMSCKEDITOR.DELETE_FAILED);
+                    }
+                });
+            }
+        });
+    }
+    onSaveAsTemplate() {
+        const jsonContent = JSON.stringify(this.rappid.graph.toJSON());
+        let template = new QMSCKEditorFlowchart();
+        template = {
+            id: guidHelper.empty,
+            jsonContent: jsonContent,
+            isTemplate: true,
+            templateName: ''
+        };
+        let data = new QMSCKEditorSaveAsTemplate();
+        data.templateType = CKEditorEventConst.QMSCK_FLOWCHART;
+        data.flowchart = template;
+        const dialogTemplate = this.dialog.open(SaveTemplateComponent, {
+            width: '450px',
+            height: '220px',
+            data,
+            disableClose: true
+        });
+        dialogTemplate
+            .afterClosed()
+            .pipe(takeUntil(this.ngUnsubcribe))
+            .subscribe((result) => {
+            if (result) {
+                this.addItem2Template(result);
+            }
+        });
+    }
+    onResetTemplate() {
+        if (window[FlowChartConst.KS_IS_SELECTED_TEMPLATE]) {
+            const orgTemplate = window[FlowChartConst.KS_ORG_JSONCONTENT] ? window[FlowChartConst.KS_ORG_JSONCONTENT] : '';
+            if (orgTemplate) {
+                this.rappid.graph.fromJSON(JSON.parse(orgTemplate));
+                this.setDefaultSelectedValue();
+                window[FlowChartConst.KS_IS_SELECTED_TEMPLATE] = false;
+            }
+        }
+    }
+    showInfoMessage(title, content) {
+        const data = new QMSCKEditorDialogData();
+        data.title = title;
+        data.content = content;
+        data.isMessage = true;
+        const dialogRef = this.dialog.open(QMSCKEditorConfirmComponent, {
+            width: '500px',
+            minHeight: '175px',
+            data
+        });
+        dialogRef
+            .afterClosed()
+            .pipe(takeUntil(this.ngUnsubcribe))
+            .subscribe((result) => {
+            if (result) {
+                //TODO
+            }
+        });
+    }
+    onCloseDialog() {
+        this.dialogRef.close();
+    }
+}
+QMSCKEditorFlowchartComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'qms-flowchart',
+                template: "<div id=\"qmsckeditor-flowchart\" class=\"qmsckeditor qmsckeditor__flowchart__container\">\r\n    <div id=\"qmsckeditor-flowchart-header\">\r\n        <span id=\"qmsckeditor-flowchart-header_001\" mat-icon-button class=\"qmsckeditor button__close\"\r\n            (click)=\"onCloseDialog()\">\r\n            <mat-icon>close</mat-icon>\r\n        </span>\r\n        <span id=\"qmsckeditor-flowchart-header_002\" mat-icon-button class=\"qmsckeditor button__done\"\r\n            (click)=\"onInsertImage()\">\r\n            <mat-icon>done</mat-icon>\r\n        </span>\r\n        <div id=\"qmsckeditor-flowchart-header_002\" mat-dialog-content>\r\n            <h2 id=\"qmsckeditor-flowchart_002_001\">{{ LANG.BPMN.FLOWCHART }}</h2>\r\n        </div>\r\n    </div>\r\n    <div id=\"flowchart\" class=\"flowchart__editor\">\r\n        <div class=\"joint-app joint-theme-modern\">\r\n            <div class=\"app-header\">\r\n                <div class=\"app-title\">\r\n                    <h1>{{ LANG.BPMN.HANDBOOK }}</h1>\r\n                </div>\r\n                <div id=\"flowcharttoolbar\" class=\"toolbar-container\"></div>\r\n            </div>\r\n            <div class=\"app-body\">\r\n                <div id=\"contentpanel\">\r\n                    <div id=\"stencilpanel\">\r\n                        <div id=\"flowchartstencil\" class=\"stencil-container\"></div>\r\n                    </div>\r\n                    <div id=\"paperpanel\">\r\n                        <div class=\"paper-container\"></div>\r\n                        <div id=\"themepicker\"></div>\r\n                    </div>\r\n                    <div id=\"rightpanel\">\r\n                        <div id=\"inspectorpanel\">\r\n                            <div class=\"inspector-container\"></div>\r\n                        </div>\r\n                        <div id=\"navigatorpanel\">\r\n                            <div class=\"navigator-container\"></div>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>",
+                styles: [".qmsckeditor__flowchart__container ::ng-deep .mat-dialog-content{padding:0}.qmsckeditor__flowchart__container .flowchart__editor{width:100%;height:600px}.qmsckeditor__flowchart__container #contentpanel{display:flex;flex-direction:row;justify-content:center;align-items:center}.qmsckeditor__flowchart__container #paperpanel{position:relative;top:0;bottom:0;left:0;right:0;height:540px;width:60%;overflow-y:auto}.qmsckeditor__flowchart__container #paperpanel .paper-container{overflow-y:auto;width:100%;height:100%}.qmsckeditor__flowchart__container #stencilpanel{position:relative;top:0;bottom:0;left:0;right:0;height:540px;width:20%}.qmsckeditor__flowchart__container #rightpanel{display:flex;flex-direction:column;align-items:center;width:20%;height:540px}.qmsckeditor__flowchart__container #rightpanel #inspectorpanel{overflow-y:auto;width:100%;height:80%}.qmsckeditor__flowchart__container #rightpanel #navigatorpanel{width:100%;height:20%}.qmsckeditor__flowchart__container #themepicker{position:absolute;right:0;bottom:0}"]
+            },] }
+];
+QMSCKEditorFlowchartComponent.ctorParameters = () => [
+    { type: MatDialog },
+    { type: ElementRef },
+    { type: TranslateLibraryService },
+    { type: QMSCKEditorFlowchartService },
+    { type: MatDialogRef },
+    { type: String, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] }
+];
+QMSCKEditorFlowchartComponent.propDecorators = {
+    onMessage: [{ type: HostListener, args: ['window:message', ['$event'],] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qms-ckeditor-flowchart.component.js","sourceRoot":"","sources":["../../../../../../../projects/qms-angular/src/lib/qms-ckeditor-components/components/qms-ckeditor-flowchart/qms-ckeditor-flowchart.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, ElementRef, HostListener, Inject, OnInit } from \"@angular/core\";\r\nimport { MatDialog, MatDialogRef, MAT_DIALOG_DATA } from \"@angular/material/dialog\";\r\nimport { takeUntil } from \"rxjs/operators\";\r\nimport { TranslateLibraryService } from \"../../../services/translation-registry.service\";\r\nimport { CKEditorEventConst } from \"../../common/constants/ckeditorEvent.constant\";\r\nimport { FlowChartConst } from \"../../common/constants/ckeditorFlowchart.const\";\r\nimport { KeyboardService } from \"../../common/flowchart/service/keyboard-service\";\r\nimport RappidService from '../../common/flowchart/service/kitchensink-service';\r\nimport { ThemePicker } from \"../../common/flowchart/themes/theme-picker\";\r\nimport guidHelper from \"../../common/helper/guidHelper\";\r\nimport { QMSCKEditorDialogData } from \"../../common/models/qms-ckeditor-dialog.model\";\r\nimport { QMSCKEditorFlowchartTemplate } from \"../../common/models/qms-ckeditor-flowchart-template.model\";\r\nimport { QMSCKEditorFlowchart } from \"../../common/models/qms-ckeditor-flowchart.model\";\r\nimport { QMSCKEditorSaveAsTemplate } from \"../../common/models/qms-ckeditor-save-as-template.model\";\r\nimport { QMSCKEditorConfirmComponent } from \"../../common/module/confirm/qms-ckeditor-confirm.component\";\r\nimport { QMSCKEditorToastService } from \"../../common/toast/qms-ckeditor-toast.service\";\r\nimport { QMSCKEditorBaseComponent } from \"../../qms-ckeditor-base.component\";\r\nimport { QMSCKEditorFlowchartService } from \"../../services/qms-ckeditor-flowchart.service\";\r\nimport { SaveTemplateComponent } from \"../qms-ckeditor-bpmn/save-template/save-template.component\";\r\n\r\n@Component({\r\n  selector: 'qms-flowchart',\r\n  templateUrl: './qms-ckeditor-flowchart.component.html',\r\n  styleUrls: ['./qms-ckeditor-flowchart.component.scss']\r\n})\r\n\r\nexport class QMSCKEditorFlowchartComponent extends QMSCKEditorBaseComponent implements OnInit, AfterViewInit {\r\n  LANG: any;\r\n  jsonContent: string = '';\r\n  rappid: RappidService;\r\n  id = '';\r\n  flowchart: QMSCKEditorFlowchart = new QMSCKEditorFlowchart();\r\n  flowchartTemplates: QMSCKEditorFlowchartTemplate[] = [];\r\n  toolbarConfig: any;\r\n\r\n  constructor(\r\n    private dialog: MatDialog,\r\n    private element: ElementRef,\r\n    private translate: TranslateLibraryService,\r\n    private flowchartService: QMSCKEditorFlowchartService,\r\n    public dialogRef: MatDialogRef<QMSCKEditorFlowchartComponent>,\r\n    @Inject(MAT_DIALOG_DATA) public data: string) {\r\n    super();\r\n    this.id = data;\r\n  }\r\n\r\n  @HostListener('window:message', ['$event'])\r\n  onMessage(event) {\r\n    if (event.data === FlowChartConst.KS_CHANGE_TEMPLATE) {\r\n      this.onChangeTemplate();\r\n    }\r\n    else if (event.data === FlowChartConst.KS_DELETE_TEMPLATE) {\r\n      this.onDeleteTemplate(this.LANG.BPMN.DELETE_TEMPLATE, this.LANG.QMSCKEDITOR_MESSAGE.CONFIRM_DELETE_TEMPLATE)\r\n    }\r\n    else if (event.data === FlowChartConst.MUST_SELECT_TEMPLATE) {\r\n      this.showInfoMessage(this.LANG.BPMN.SELECT_TEMPLATE, this.LANG.BPMN.SELECT_TEMPLATE_INFORMATION);\r\n    }\r\n    else if (event.data === FlowChartConst.KS_SAVE_AS_TEMPLATE) {\r\n      this.onSaveAsTemplate();\r\n    }\r\n    else if (event.data === FlowChartConst.KS_RESET_TEMPLATE) {\r\n      this.onResetTemplate();\r\n    }\r\n  }\r\n\r\n  async ngOnInit(): Promise<void> {\r\n    this.translate.getLanguageSubject$.pipe(takeUntil(this.ngUnsubcribe)).subscribe((res) => {\r\n      if (res) {\r\n        this.LANG = this.translate.getObjectLang(res);\r\n      }\r\n    });\r\n\r\n    if (this.id) {\r\n      this.jsonContent = await this.getJsonContent(this.id);\r\n    }\r\n    this.rappid = new RappidService(\r\n      this.element.nativeElement,\r\n      new KeyboardService(),\r\n      this.LANG\r\n    );\r\n\r\n    this.rappid.startRappid();\r\n\r\n    const themePicker = new ThemePicker({ mainView: this.rappid });\r\n    themePicker.render().$el.appendTo(document.getElementById('themepicker'));\r\n\r\n    if (this.jsonContent) {\r\n      this.rappid.graph.fromJSON(JSON.parse(this.jsonContent));\r\n    }\r\n  }\r\n\r\n  async ngAfterViewInit(): Promise<void> {\r\n    this.flowchartTemplates = await this.getTemplates();\r\n    this.initializeTemplates(this.flowchartTemplates);\r\n  }\r\n\r\n\r\n  async getJsonContent(id: string): Promise<string> {\r\n    return new Promise((resolve) => {\r\n      this.flowchartService\r\n        .getFlowchartById(id)\r\n        .pipe(takeUntil(this.ngUnsubcribe))\r\n        .subscribe((result) => {\r\n          if (result) {\r\n            resolve(result.jsonContent);\r\n          }\r\n        });\r\n    })\r\n  }\r\n\r\n  async getTemplates(): Promise<QMSCKEditorFlowchartTemplate[]> {\r\n    return new Promise((resolve) => {\r\n      this.flowchartService\r\n        .flowchartGetTemplates()\r\n        .pipe(takeUntil(this.ngUnsubcribe))\r\n        .subscribe((result) => {\r\n          resolve(result);\r\n        })\r\n    })\r\n  }\r\n\r\n  initializeTemplates(templates: QMSCKEditorFlowchartTemplate[]) {\r\n    if (templates) {\r\n      this.toolbarConfig = this.rappid.toolbar;\r\n      const arrSelect = this.toolbarConfig.tools.filter((item) => {\r\n        return item.type === 'select-box';\r\n      });\r\n      if (arrSelect && arrSelect[0]) {\r\n        templates.forEach((item) => {\r\n          const option = {\r\n            index: item.index,\r\n            content: item.templateName,\r\n            flowChartId: item.id,\r\n            name: item.templateName,\r\n            jsonContent: item.jsonContent,\r\n            selected: false\r\n          };\r\n          const index = arrSelect[0].options.findIndex((x) => {\r\n            return x.index === option.index;\r\n          });\r\n          if (index < 0) {\r\n            arrSelect[0].options.push(option);\r\n          }\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  addItem2Template(template?: QMSCKEditorFlowchartTemplate) {\r\n    this.toolbarConfig = this.rappid.toolbar;\r\n    const arrSelect = this.toolbarConfig.tools.filter((item) => {\r\n      return item.type === 'select-box';\r\n    });\r\n    if (arrSelect) {\r\n      const option = {\r\n        index: 1,\r\n        content: template.templateName,\r\n        flowChartId: template.id,\r\n        name: template.templateName,\r\n        jsonContent: template.jsonContent,\r\n        selected: false\r\n      };\r\n      arrSelect[0].options.push(option);\r\n    }\r\n  }\r\n\r\n  removeSelectedValue(flowChartId?: string) {\r\n    this.toolbarConfig = this.rappid.toolbar;\r\n    const arrSelect = this.toolbarConfig.tools.filter((item) => {\r\n      return item.type === 'select-box';\r\n    });\r\n    if (arrSelect) {\r\n      arrSelect[0].options.splice(\r\n        arrSelect[0].options.findIndex((i) => {\r\n          return i.flowChartId === flowChartId;\r\n        }),\r\n        1\r\n      );\r\n    }\r\n  }\r\n\r\n  setDefaultSelectedValue() {\r\n    this.toolbarConfig = this.rappid.toolbar;\r\n    const arrSelect = this.toolbarConfig.tools.filter((item) => {\r\n      return item.type === 'select-box';\r\n    });\r\n    if (arrSelect) {\r\n      arrSelect[0].options[0].selected = true;\r\n      const list = document.getElementsByClassName(`select-box-selection`)[0];\r\n      list.getElementsByClassName(`select-box-option-content`)[0].innerHTML = FlowChartConst.SELECT_TEMPLATE;\r\n    }\r\n  }\r\n\r\n  async saveImageContent() {\r\n    return new Promise((resolve) => {\r\n      const jsonContent = this.rappid.getJsonContent();\r\n      this.flowchart = {\r\n        id: this.id ? this.id : guidHelper.empty,\r\n        jsonContent: jsonContent,\r\n        isTemplate: false,\r\n        templateName: ''\r\n      }\r\n\r\n      this.flowchartService\r\n        .flowchartModifying(this.flowchart)\r\n        .pipe(takeUntil(this.ngUnsubcribe))\r\n        .subscribe((result) => {\r\n          if (result) {\r\n            resolve(result);\r\n          }\r\n        });\r\n    })\r\n  }\r\n\r\n  async onInsertImage() {\r\n    const id = await this.saveImageContent();\r\n    const imageContent = await this.rappid.getImageContent();\r\n    const result = { key: `${CKEditorEventConst.QMSCK_FLOWCHART}#${id}`, values: imageContent }\r\n    this.dialogRef.close(result);\r\n  }\r\n\r\n  onChangeTemplate() {\r\n    const jsonTemplate = window[FlowChartConst.KS_SELECTED_JSONCONTENT] ? window[FlowChartConst.KS_SELECTED_JSONCONTENT] : '';\r\n    if (!window[FlowChartConst.KS_IS_SELECTED_TEMPLATE]) {\r\n      window[FlowChartConst.KS_ORG_JSONCONTENT] = JSON.stringify(this.rappid.graph.toJSON());\r\n      window[FlowChartConst.KS_IS_SELECTED_TEMPLATE] = true;\r\n    }\r\n    if (jsonTemplate) {\r\n      this.rappid.graph.fromJSON(JSON.parse(jsonTemplate));\r\n    }\r\n  }\r\n\r\n  onDeleteTemplate(title: string, content: string) {\r\n    const data: QMSCKEditorDialogData = new QMSCKEditorDialogData();\r\n    data.title = title;\r\n    data.content = content;\r\n    const dialogRef = this.dialog.open(QMSCKEditorConfirmComponent, {\r\n      width: '500px',\r\n      minHeight: '175px',\r\n      data\r\n    });\r\n    dialogRef\r\n      .afterClosed()\r\n      .pipe(takeUntil(this.ngUnsubcribe))\r\n      .subscribe((result) => {\r\n        if (result) {\r\n          const id = window[FlowChartConst.KS_SELECTED_FLOWCHART_ID];\r\n          this.flowchartService\r\n            .flowchartDeleteTemplate(id)\r\n            .pipe(takeUntil(this.ngUnsubcribe))\r\n            .subscribe((result) => {\r\n              if (result) {\r\n                this.removeSelectedValue(id);\r\n                this.setDefaultSelectedValue();\r\n                window[FlowChartConst.KS_IS_SELECTED_TEMPLATE] = false;\r\n                QMSCKEditorToastService.success(this.LANG.QMSCKEDITOR.DELETED);\r\n              }\r\n              else {\r\n                QMSCKEditorToastService.error(this.LANG.QMSCKEDITOR.DELETE_FAILED);\r\n              }\r\n            })\r\n        }\r\n      });\r\n  }\r\n\r\n  onSaveAsTemplate() {\r\n    const jsonContent = JSON.stringify(this.rappid.graph.toJSON());\r\n    let template = new QMSCKEditorFlowchart();\r\n    template = {\r\n      id: guidHelper.empty,\r\n      jsonContent: jsonContent,\r\n      isTemplate: true,\r\n      templateName: ''\r\n    }\r\n    let data = new QMSCKEditorSaveAsTemplate();\r\n    data.templateType = CKEditorEventConst.QMSCK_FLOWCHART;\r\n    data.flowchart = template;\r\n    const dialogTemplate = this.dialog.open(SaveTemplateComponent, {\r\n      width: '450px',\r\n      height: '220px',\r\n      data,\r\n      disableClose: true\r\n    });\r\n    dialogTemplate\r\n      .afterClosed()\r\n      .pipe(takeUntil(this.ngUnsubcribe))\r\n      .subscribe((result) => {\r\n        if (result) {\r\n          this.addItem2Template(result);\r\n        }\r\n      });\r\n  }\r\n\r\n  onResetTemplate() {\r\n    if (window[FlowChartConst.KS_IS_SELECTED_TEMPLATE]) {\r\n      const orgTemplate = window[FlowChartConst.KS_ORG_JSONCONTENT] ? window[FlowChartConst.KS_ORG_JSONCONTENT] : '';\r\n      if (orgTemplate) {\r\n        this.rappid.graph.fromJSON(JSON.parse(orgTemplate));\r\n        this.setDefaultSelectedValue();\r\n        window[FlowChartConst.KS_IS_SELECTED_TEMPLATE] = false;\r\n      }\r\n    }\r\n  }\r\n\r\n  showInfoMessage(title: string, content: string) {\r\n    const data: QMSCKEditorDialogData = new QMSCKEditorDialogData();\r\n    data.title = title;\r\n    data.content = content;\r\n    data.isMessage = true;\r\n    const dialogRef = this.dialog.open(QMSCKEditorConfirmComponent, {\r\n      width: '500px',\r\n      minHeight: '175px',\r\n      data\r\n    });\r\n    dialogRef\r\n      .afterClosed()\r\n      .pipe(takeUntil(this.ngUnsubcribe))\r\n      .subscribe((result) => {\r\n        if (result) {\r\n          //TODO\r\n        }\r\n      });\r\n  }\r\n\r\n  onCloseDialog() {\r\n    this.dialogRef.close();\r\n  }\r\n}\r\n"]}