qms-angular 1.0.36 → 1.0.40

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

@@ -0,0 +1,266 @@
+import { __awaiter } from "tslib";
+import { Component, 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 guidHelper from "../../common/helper/guidHelper";
+import { QMSCKEditorBpmn } from "../../common/models/qms-ckeditor-bpmn.model";
+import { QMSCKEditorDialogData } from "../../common/models/qms-ckeditor-dialog.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 { QMSCKEditorBpmnApiService } from "../../services/qms-ckeditor-bpmn-api.service";
+import { BpmnService } from "../../services/qms-ckeditor-bpmn.service";
+import { SaveTemplateComponent } from "./save-template/save-template.component";
+export class QMSCKEditorBpmnComponent extends QMSCKEditorBaseComponent {
+    constructor(dialog, translate, bmpnService, bpmnApiService, dialogRef, data) {
+        super();
+        this.dialog = dialog;
+        this.translate = translate;
+        this.bmpnService = bmpnService;
+        this.bpmnApiService = bpmnApiService;
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.expandedPanel = true;
+        this.id = '';
+        this.bpmn = new QMSCKEditorBpmn();
+        this.bpmnTemlates = [];
+        this.id = data;
+    }
+    onMessage(event) {
+        if (event.data === FlowChartConst.SAVE_AS_TEMPLATE) {
+            this.onSaveAsTemplate();
+        }
+        else if (event.data === FlowChartConst.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.CHANGING_TEMPLATE) {
+            this.onSelectedTemplate();
+        }
+        else if (event.data === FlowChartConst.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);
+                }
+            });
+            this.bpmnTemlates = yield this.getTemplates();
+            if (this.id) {
+                this.jsonContent = yield this.getJsonContent(this.id);
+            }
+            this.bmpnService.buildDiagram(this.bpmnTemlates, null, CKEditorEventConst.QMSCK_BPMN, this.jsonContent, 1, this.LANG);
+        });
+    }
+    expandPanel() {
+        this.expandedPanel = !this.expandedPanel;
+        const panelStencil = document.getElementById('panel-stencil-container');
+        const paperContainer = document.getElementById('paperpanel');
+        const stencilContainer = document.getElementById('stencilpanel');
+        if (panelStencil) {
+            if (!this.expandedPanel) {
+                stencilContainer.style.height = '50px';
+                panelStencil.style.height = '50px';
+                paperContainer.style.height = '500px';
+            }
+            else {
+                stencilContainer.style.height = '150px';
+                panelStencil.style.height = '150px';
+                paperContainer.style.height = '400px';
+            }
+        }
+    }
+    getTemplates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                this.bpmnApiService
+                    .bpmnGetTemplates()
+                    .pipe(takeUntil(this.ngUnsubcribe))
+                    .subscribe((result) => {
+                    resolve(result);
+                });
+            });
+        });
+    }
+    getJsonContent(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                this.bpmnApiService
+                    .getBpmnById(id)
+                    .pipe(takeUntil(this.ngUnsubcribe))
+                    .subscribe((result) => {
+                    if (result) {
+                        resolve(result.jsonContent);
+                    }
+                });
+            });
+        });
+    }
+    saveImageContent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                const graph = window[FlowChartConst.GRAPH];
+                const jsonContent = JSON.stringify(graph.toJSON());
+                this.bpmn = {
+                    id: this.id ? this.id : guidHelper.empty,
+                    jsonContent: jsonContent,
+                    isTemplate: false,
+                    templateName: ''
+                };
+                this.bpmnApiService
+                    .bpmnModifying(this.bpmn)
+                    .pipe(takeUntil(this.ngUnsubcribe))
+                    .subscribe((result) => {
+                    if (result) {
+                        resolve(result);
+                    }
+                });
+            });
+        });
+    }
+    getImageContent(paper) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                paper.toPNG((imageData) => {
+                    const arrString = imageData.split(',');
+                    resolve(arrString[1]);
+                });
+            });
+        });
+    }
+    onInsertImage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = yield this.saveImageContent();
+            const paper = window[`paper`];
+            const imageContent = 'data:image/png;base64,' + (yield this.getImageContent(paper));
+            const result = { key: `${CKEditorEventConst.QMSCK_BPMN}#${id}`, values: imageContent };
+            this.dialogRef.close(result);
+        });
+    }
+    onCloseDialog() {
+        this.dialogRef.close();
+    }
+    onSaveAsTemplate() {
+        const graph = window[FlowChartConst.GRAPH];
+        const jsonContent = JSON.stringify(graph.toJSON());
+        let data = new QMSCKEditorBpmn();
+        data = {
+            id: guidHelper.empty,
+            jsonContent: jsonContent,
+            isTemplate: true,
+            templateName: ''
+        };
+        const dialogTemplate = this.dialog.open(SaveTemplateComponent, {
+            width: '450px',
+            height: '220px',
+            data,
+            disableClose: true
+        });
+        dialogTemplate
+            .afterClosed()
+            .pipe(takeUntil(this.ngUnsubcribe))
+            .subscribe((result) => {
+            if (result) {
+                // TDO
+            }
+        });
+    }
+    onSelectedTemplate() {
+        const selectedJsonContent = window[FlowChartConst.SELECTED_JSON_CONTENT];
+        if (selectedJsonContent) {
+            const graph = window[FlowChartConst.GRAPH];
+            if (graph) {
+                graph.fromJSON(JSON.parse(selectedJsonContent));
+            }
+        }
+    }
+    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.SELECTED_FLOWCHART_ID];
+                this.bpmnApiService
+                    .bpmnDeleteTemplate(id)
+                    .pipe(takeUntil(this.ngUnsubcribe))
+                    .subscribe((result) => {
+                    if (result) {
+                        this.bmpnService.removeSelectItem(id);
+                        this.bmpnService.setDefaultSelectedValue();
+                        window[FlowChartConst.IS_SELECTED_TEMPLATE] = false;
+                        QMSCKEditorToastService.success(this.LANG.QMSCKEDITOR.DELETED);
+                    }
+                    else {
+                        QMSCKEditorToastService.error(this.LANG.QMSCKEDITOR.DELETE_FAILED);
+                    }
+                });
+            }
+        });
+    }
+    onResetTemplate() {
+        const ogrJsonContent = window[FlowChartConst.ORG_JSONCONTENT];
+        if (ogrJsonContent) {
+            const graph = window[FlowChartConst.GRAPH];
+            if (graph) {
+                graph.fromJSON(JSON.parse(ogrJsonContent));
+                this.bmpnService.setDefaultSelectedValue();
+                window[FlowChartConst.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
+            }
+        });
+    }
+}
+QMSCKEditorBpmnComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'qms-bpmn',
+                template: "<div id=\"qmsckeditor-bpmn\" class=\"qmsckeditor qmsckeditor__bpmn__container\">\r\n  <div id=\"qmsckeditor-load-template-header\">\r\n    <span\r\n      id=\"qmsckeditor-bpmn-header_001\"\r\n      mat-icon-button\r\n      class=\"qmsckeditor button__close\"\r\n      (click)=\"onCloseDialog()\"\r\n    >\r\n      <mat-icon>close</mat-icon>\r\n    </span>\r\n    <span\r\n      id=\"qmsckeditor-bpmn-header_002\"\r\n      mat-icon-button\r\n      class=\"qmsckeditor button__done\"\r\n      (click)=\"onInsertImage()\"\r\n    >\r\n      <mat-icon>done</mat-icon>\r\n    </span>\r\n    <div id=\"qmsckeditor-load-template-header_002\" mat-dialog-content>\r\n      <h2 id=\"qmsckeditor-template_002_001\">\r\n        Business Process Model and Notation\r\n      </h2>\r\n    </div>\r\n  </div>\r\n\r\n  <div id=\"bpmn\" class=\"bpmn__editor\">\r\n    <div id=\"toolbarpanel\">\r\n      <div id=\"toolbar-container\"></div>\r\n    </div>\r\n    <div id=\"leftpanel\">\r\n      <div id=\"paperpanel\">\r\n        <div id=\"paper-container\"></div>\r\n      </div>\r\n      <div id=\"stencilpanel\">\r\n        <mat-expansion-panel\r\n          id=\"panel-stencil-container\"\r\n          [expanded]=\"expandedPanel\"\r\n          (click)=\"expandPanel()\"\r\n        >\r\n          <mat-expansion-panel-header>\r\n            <mat-panel-title> </mat-panel-title>\r\n          </mat-expansion-panel-header>\r\n          <div id=\"stencil-container\"></div>\r\n        </mat-expansion-panel>\r\n        <!-- <div id=\"stencil-container\"></div> -->\r\n      </div>\r\n    </div>\r\n    <div id=\"rightpanel\">\r\n      <div id=\"inspector-container\">\r\n        <div class=\"about\">\r\n          <h1>Business Process Model and Notation</h1>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</div>\r\n",
+                styles: [".qmsckeditor__bpmn__container .bpmn__editor{width:100%;height:600px}.qmsckeditor__bpmn__container #leftpanel{float:left;width:70%;height:550px}.qmsckeditor__bpmn__container #rightpanel{float:right;width:30%;height:550px;border:solid;border-width:0 1px 1px 0;overflow-y:auto}.qmsckeditor__bpmn__container #toolbarpanel{position:relative;top:0;bottom:0;left:0;right:0;margin-bottom:17px;height:50px;width:100%}.qmsckeditor__bpmn__container #paperpanel{position:relative;top:0;bottom:0;left:0;right:0;height:400px;width:100%}.qmsckeditor__bpmn__container #stencilpanel{position:relative;top:0;bottom:0;left:0;right:0;height:150px;width:100%}.qmsckeditor__bpmn__container #toolbar-container{position:relative;top:0;bottom:0;left:0;right:0;width:100%;height:100%}.qmsckeditor__bpmn__container #paper-container{position:relative;top:0;bottom:0;left:0;right:0;width:100%;height:inherit}.qmsckeditor__bpmn__container #inspector-container{position:relative;top:0;right:0;bottom:0;width:100%;background:#fff}.qmsckeditor__bpmn__container #stencil-container{position:absolute;top:0;bottom:0;left:0;right:0;width:1174px;height:inherit}.qmsckeditor__bpmn__container #statusbar-container{position:absolute;left:0;right:0;bottom:0;height:25px}.qmsckeditor__bpmn__container #panel-stencil-container{position:absolute;left:0;right:0;bottom:0;height:150px;overflow-x:auto;overflow-y:hidden;background-image:url(\"data:image/png;base64,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\");background-repeat:repeat;transition:all .5s ease-in-out 0s}.qmsckeditor__bpmn__container #panel-stencil-container .mat-expansion-panel-header-title{color:#fff}.qmsckeditor__bpmn__container #panel-stencil-container .joint-theme-default{background:none}.qmsckeditor__bpmn__container #panel-stencil-container ::ng-deep .mat-expansion-indicator:after{color:#fff;transform:rotate(-135deg)}.qmsckeditor__bpmn__container #panel-stencil-container .mat-expansion-panel-header{min-width:1224px;max-width:100%}.qmsckeditor__bpmn__container #panel-stencil-container .joint-stencil>.content{width:1200px}.qmsckeditor__bpmn__container ::ng-deep .joint-inspector.joint-theme-bpmn .list-item .input-wrapper input{width:70%;float:none}"]
+            },] }
+];
+QMSCKEditorBpmnComponent.ctorParameters = () => [
+    { type: MatDialog },
+    { type: TranslateLibraryService },
+    { type: BpmnService },
+    { type: QMSCKEditorBpmnApiService },
+    { type: MatDialogRef },
+    { type: String, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] }
+];
+QMSCKEditorBpmnComponent.propDecorators = {
+    onMessage: [{ type: HostListener, args: ['window:message', ['$event'],] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qms-ckeditor-bpmn.component.js","sourceRoot":"","sources":["../../../../../../../projects/qms-angular/src/lib/qms-ckeditor-components/components/qms-ckeditor-bpmn/qms-ckeditor-bpmn.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, 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 guidHelper from \"../../common/helper/guidHelper\";\r\nimport { QMSCKEditorBpmnTemplate } from \"../../common/models/qms-ckeditor-bpmn-template.model\";\r\nimport { QMSCKEditorBpmn } from \"../../common/models/qms-ckeditor-bpmn.model\";\r\nimport { QMSCKEditorDialogData } from \"../../common/models/qms-ckeditor-dialog.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 { QMSCKEditorBpmnApiService } from \"../../services/qms-ckeditor-bpmn-api.service\";\r\nimport { BpmnService } from \"../../services/qms-ckeditor-bpmn.service\";\r\nimport { SaveTemplateComponent } from \"./save-template/save-template.component\";\r\n\r\n@Component({\r\n  selector: 'qms-bpmn',\r\n  templateUrl: './qms-ckeditor-bpmn.component.html',\r\n  styleUrls: ['./qms-ckeditor-bpmn.component.scss']\r\n})\r\nexport class QMSCKEditorBpmnComponent extends QMSCKEditorBaseComponent implements OnInit {\r\n  LANG: any;\r\n  jsonContent: string;\r\n  expandedPanel = true;\r\n  id = '';\r\n  bpmn: QMSCKEditorBpmn = new QMSCKEditorBpmn();\r\n  bpmnTemlates: QMSCKEditorBpmnTemplate[] = [];\r\n\r\n  constructor(\r\n    private dialog: MatDialog,\r\n    private translate: TranslateLibraryService,\r\n    private bmpnService: BpmnService,\r\n    private bpmnApiService: QMSCKEditorBpmnApiService,\r\n    public dialogRef: MatDialogRef<QMSCKEditorBpmnComponent>,\r\n    @Inject(MAT_DIALOG_DATA) public data: string\r\n  ) {\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.SAVE_AS_TEMPLATE) {\r\n      this.onSaveAsTemplate();\r\n    }\r\n    else if (event.data === FlowChartConst.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.CHANGING_TEMPLATE) {\r\n      this.onSelectedTemplate();\r\n    }\r\n    else if (event.data === FlowChartConst.RESET_TEMPLATE) {\r\n      this.onResetTemplate();\r\n    }\r\n  }\r\n\r\n  async ngOnInit() {\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    this.bpmnTemlates = await this.getTemplates();\r\n    if (this.id) {\r\n      this.jsonContent = await this.getJsonContent(this.id);\r\n    }\r\n    this.bmpnService.buildDiagram(\r\n      this.bpmnTemlates,\r\n      null,\r\n      CKEditorEventConst.QMSCK_BPMN,\r\n      this.jsonContent,\r\n      1,\r\n      this.LANG\r\n    );\r\n  }\r\n\r\n  expandPanel() {\r\n    this.expandedPanel = !this.expandedPanel;\r\n    const panelStencil = document.getElementById('panel-stencil-container');\r\n    const paperContainer = document.getElementById('paperpanel');\r\n    const stencilContainer = document.getElementById('stencilpanel');\r\n    if (panelStencil) {\r\n      if (!this.expandedPanel) {\r\n        stencilContainer.style.height = '50px';\r\n        panelStencil.style.height = '50px';\r\n        paperContainer.style.height = '500px';\r\n      } else {\r\n        stencilContainer.style.height = '150px';\r\n        panelStencil.style.height = '150px';\r\n        paperContainer.style.height = '400px';\r\n      }\r\n    }\r\n  }\r\n\r\n  async getTemplates(): Promise<QMSCKEditorBpmnTemplate[]> {\r\n    return new Promise((resolve) => {\r\n      this.bpmnApiService\r\n        .bpmnGetTemplates()\r\n        .pipe(takeUntil(this.ngUnsubcribe))\r\n        .subscribe((result) => {\r\n          resolve(result);\r\n        })\r\n    })\r\n  }\r\n\r\n  async getJsonContent(id: string): Promise<string> {\r\n    return new Promise((resolve) => {\r\n      this.bpmnApiService\r\n        .getBpmnById(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 saveImageContent() {\r\n    return new Promise((resolve) => {\r\n      const graph = window[FlowChartConst.GRAPH];\r\n      const jsonContent = JSON.stringify(graph.toJSON());\r\n      this.bpmn = {\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.bpmnApiService\r\n        .bpmnModifying(this.bpmn)\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 getImageContent(paper: any) {\r\n    return new Promise((resolve) => {\r\n      paper.toPNG((imageData) => {\r\n        const arrString = imageData.split(',');\r\n        resolve(arrString[1]);\r\n      });\r\n    });\r\n  }\r\n\r\n  async onInsertImage() {\r\n    const id = await this.saveImageContent();\r\n    const paper = window[`paper`];\r\n    const imageContent = 'data:image/png;base64,' + await this.getImageContent(paper);\r\n    const result = { key: `${CKEditorEventConst.QMSCK_BPMN}#${id}`, values: imageContent }\r\n    this.dialogRef.close(result);\r\n  }\r\n\r\n  onCloseDialog() {\r\n    this.dialogRef.close();\r\n  }\r\n\r\n  onSaveAsTemplate() {\r\n    const graph = window[FlowChartConst.GRAPH];\r\n    const jsonContent = JSON.stringify(graph.toJSON());\r\n    let data = new QMSCKEditorBpmn();\r\n    data = {\r\n      id: guidHelper.empty,\r\n      jsonContent: jsonContent,\r\n      isTemplate: true,\r\n      templateName: ''\r\n    }\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          // TDO\r\n        }\r\n      });\r\n  }\r\n\r\n  onSelectedTemplate() {\r\n    const selectedJsonContent = window[FlowChartConst.SELECTED_JSON_CONTENT];\r\n    if (selectedJsonContent) {\r\n      const graph = window[FlowChartConst.GRAPH];\r\n      if (graph) {\r\n        graph.fromJSON(JSON.parse(selectedJsonContent));\r\n      }\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.SELECTED_FLOWCHART_ID];\r\n          this.bpmnApiService\r\n            .bpmnDeleteTemplate(id)\r\n            .pipe(takeUntil(this.ngUnsubcribe))\r\n            .subscribe((result) => {\r\n              if (result) {\r\n                this.bmpnService.removeSelectItem(id);\r\n                this.bmpnService.setDefaultSelectedValue();\r\n                window[FlowChartConst.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  onResetTemplate() {\r\n    const ogrJsonContent = window[FlowChartConst.ORG_JSONCONTENT];\r\n    if (ogrJsonContent) {\r\n      const graph = window[FlowChartConst.GRAPH];\r\n      if (graph) {\r\n        graph.fromJSON(JSON.parse(ogrJsonContent));\r\n        this.bmpnService.setDefaultSelectedValue();\r\n        window[FlowChartConst.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"]}

package/esm2015/lib/qms-ckeditor-components/components/qms-ckeditor-bpmn/save-template/save-template.component.js

@@ -0,0 +1,67 @@
+import { Component, Inject } from "@angular/core";
+import { FormControl, FormGroup, Validators } from "@angular/forms";
+import { MatDialogRef, MAT_DIALOG_DATA } from "@angular/material/dialog";
+import { takeUntil } from "rxjs/operators";
+import { TranslateLibraryService } from "../../../../services/translation-registry.service";
+import { QMSCKEditorBpmn } from "../../../common/models/qms-ckeditor-bpmn.model";
+import { QMSCKEditorToastService } from "../../../common/toast/qms-ckeditor-toast.service";
+import { QMSCKEditorBaseComponent } from "../../../qms-ckeditor-base.component";
+import { QMSCKEditorBpmnApiService } from "../../../services/qms-ckeditor-bpmn-api.service";
+import { BpmnService } from "../../../services/qms-ckeditor-bpmn.service";
+export class SaveTemplateComponent extends QMSCKEditorBaseComponent {
+    constructor(translate, bmpnService, bpmnApiService, dialogRef, data) {
+        super();
+        this.translate = translate;
+        this.bmpnService = bmpnService;
+        this.bpmnApiService = bpmnApiService;
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.saveFormGroup = new FormGroup({
+            templateName: new FormControl('', [Validators.required])
+        });
+        this.templateName = '';
+        this.bpmn = new QMSCKEditorBpmn();
+        this.bpmn = data;
+    }
+    ngOnInit() {
+        this.translate.getLanguageSubject$.pipe(takeUntil(this.ngUnsubcribe)).subscribe((res) => {
+            if (res) {
+                this.LANG = this.translate.getObjectLang(res);
+            }
+        });
+    }
+    saveTemplate() {
+        this.bpmn.templateName = this.templateName;
+        this.bpmnApiService
+            .bpmnModifying(this.bpmn)
+            .pipe(takeUntil(this.ngUnsubcribe))
+            .subscribe((result) => {
+            if (result) {
+                this.bmpnService.addItemTemplate(result, this.bpmn);
+                QMSCKEditorToastService.success(this.LANG.QMSCKEDITOR.SAVED);
+                this.onCloseDialog();
+            }
+            else {
+                QMSCKEditorToastService.error(this.LANG.QMSCKEDITOR.SAVE_FAILED);
+            }
+        });
+    }
+    onCloseDialog() {
+        this.dialogRef.close();
+    }
+}
+SaveTemplateComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'save-template',
+                template: "<div\r\n  id=\"qmsckeditor-bpmn\"\r\n  class=\"qmsckeditor qmsckeditor__savetemplate__container\"\r\n>\r\n  <div id=\"qmsckeditor-load-template-header\">\r\n    <span\r\n      id=\"qmsckeditor-bpmn-header_001\"\r\n      mat-icon-button\r\n      class=\"qmsckeditor button__close\"\r\n      (click)=\"onCloseDialog()\"\r\n    >\r\n      <mat-icon>close</mat-icon>\r\n    </span>\r\n    <div id=\"qmsckeditor-load-template-header_002\" mat-dialog-content>\r\n      <h2 id=\"qmsckeditor-template_002_001\">Save as template</h2>\r\n    </div>\r\n\r\n    <form [formGroup]=\"saveFormGroup\">\r\n      <div\r\n        id=\"qmsckeditor-save-as-content\"\r\n        class=\"qmsckeditor save__as__template height\"\r\n      >\r\n        <div id=\"qmsckeditor-save-as-content_001\" class=\"col-12 mt-1 pl-2 pr-2\">\r\n          <div id=\"qmsckeditor-save-as-panel_001\">\r\n            <div id=\"qmsckeditor-save-as-panel_001_001\">\r\n              <mat-form-field class=\"col-12 pl-0 pr-0\" appearance=\"fill\">\r\n                <mat-label>{{ LANG.BPMN.TEMPLATE_NAME }}</mat-label>\r\n                <input\r\n                  matInput\r\n                  formControlName=\"templateName\"\r\n                  [(ngModel)]=\"templateName\"\r\n                />\r\n                <mat-error\r\n                  *ngIf=\"saveFormGroup.get('templateName').hasError('required')\"\r\n                  class=\"mt5\"\r\n                >\r\n                </mat-error>\r\n              </mat-form-field>\r\n            </div>\r\n            <div\r\n              id=\"qmsckeditor-save-as-panel_001_003\"\r\n              class=\"qmsckeditor button__groups row mr-0 ml-0\"\r\n            >\r\n              <div class=\"col-6 pr-0\">\r\n                <button\r\n                  class=\"save\"\r\n                  mat-flat-button\r\n                  (click)=\"saveTemplate()\"\r\n                  [disabled]=\"saveFormGroup.invalid\"\r\n                >\r\n                  {{ LANG.QMSCKEDITOR.SAVE }}\r\n                </button>\r\n              </div>\r\n              <div class=\"col-6 pl-0\">\r\n                <button\r\n                  class=\"cancel\"\r\n                  mat-flat-button\r\n                  (click)=\"onCloseDialog()\"\r\n                >\r\n                  {{ LANG.QMSCKEDITOR.CANCEL }}\r\n                </button>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </form>\r\n  </div>\r\n</div>\r\n",
+                styles: [""]
+            },] }
+];
+SaveTemplateComponent.ctorParameters = () => [
+    { type: TranslateLibraryService },
+    { type: BpmnService },
+    { type: QMSCKEditorBpmnApiService },
+    { type: MatDialogRef },
+    { type: QMSCKEditorBpmn, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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