@magic-xpa/angular 4.800.0 → 4.801.0-dev000.0

package/esm2020/src/ui/magic-root.component.mjs

@@ -0,0 +1,237 @@
+import { ChangeDetectorRef, Component, ElementRef, HostListener, Input, Optional, TemplateRef, ViewChild } from '@angular/core';
+import { CommandType } from '@magic-xpa/gui';
+import { Title } from '@angular/platform-browser';
+import { EngineMagicService } from '../services/engine.magic.service';
+import { ComponentListMagicService } from '../services/component-list.magic.service';
+import { GuiInteractiveExecutor } from './GuiInteractiveExecutor';
+import { filter } from 'rxjs/operators';
+import { ExitMagicService } from '../services/exit.magic.service';
+import { OverlayWindowService } from '../services/OverlayWindowService';
+import { CommandsCollectorMagicService } from '../services/commands-collector.magic.service';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/engine.magic.service";
+import * as i2 from "../services/component-list.magic.service";
+import * as i3 from "@angular/platform-browser";
+import * as i4 from "../services/OverlayWindowService";
+import * as i5 from "@angular/common/http";
+import * as i6 from "../services/commands-collector.magic.service";
+import * as i7 from "../services/exit.magic.service";
+import * as i8 from "@angular/common";
+import * as i9 from "ng-dynamic-component";
+import * as i10 from "./directives/magicViewContainerRef.directive";
+const _c0 = ["magicRoot"];
+function MagicShellComponent_ndc_dynamic_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "ndc-dynamic", 6);
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ndcDynamicComponent", ctx_r1.RootComponent)("ndcDynamicInputs", ctx_r1.RootComponentParameters);
+} }
+function MagicShellComponent_div_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div", 7);
+    i0.ɵɵelementContainer(1, 8);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext();
+    const _r4 = i0.ɵɵreference(7);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngTemplateOutlet", ctx_r3.SpinnerTemplate ? ctx_r3.SpinnerTemplate : _r4);
+} }
+function MagicShellComponent_ng_template_6_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "div", 9);
+} }
+export class MagicShellComponent {
+    constructor(engineMagicService, componentList, changeDetectorRef, titleService, overlayWindowService, httpClient, pendingCommandsCollector, exitMagicService) {
+        this.engineMagicService = engineMagicService;
+        this.componentList = componentList;
+        this.changeDetectorRef = changeDetectorRef;
+        this.titleService = titleService;
+        this.overlayWindowService = overlayWindowService;
+        this.httpClient = httpClient;
+        this.pendingCommandsCollector = pendingCommandsCollector;
+        this.exitMagicService = exitMagicService;
+        this.RootComponent = null;
+        this.magicEngineTerminated = false;
+        this.initialize();
+        this.setTitle();
+    }
+    onBeforeUnload(event) {
+        if (this.engineMagicService.TransCacheExists()) {
+            event.returnValue = 'Are you sure?';
+            return 'Are you sure?';
+        }
+        else {
+            this.engineMagicService.TerminateContextUsingFetchAPI();
+            this.magicEngineTerminated = true;
+        }
+    }
+    onUnload(event) {
+        if (!this.magicEngineTerminated)
+            this.engineMagicService.TerminateContextUsingFetchAPI();
+    }
+    ngAfterViewInit() {
+        this.overlayWindowService.init(this.overlayWindowsContainerViewRef, this.rootMagicElementRef.nativeElement);
+        this.engineMagicService.startMagicEngine(this.httpClient);
+    }
+    setViewContainerRef(vcRef) {
+        this.overlayWindowsContainerViewRef = vcRef;
+    }
+    initialize() {
+        this.registerUICommands();
+    }
+    setTitle() {
+        const newTitle = this.componentList.title;
+        this.titleService.setTitle(newTitle);
+    }
+    setComponent(formName, taskId, taskDescription, isModal) {
+        this.pendingCommandsCollector.startCollecting();
+        if (isModal) {
+            this.overlayWindowService.open(formName, taskId, taskDescription);
+        }
+        else {
+            this.RootComponent = this.componentList.getComponent(formName);
+            this.RootComponentParameters = { taskIdParam: taskId, taskDescription: taskDescription };
+        }
+        this.changeDetectorRef.detectChanges();
+    }
+    registerUICommands() {
+        this.engineMagicService.refreshDom.pipe(filter(command => command.TaskTag === '0'))
+            .subscribe(command => {
+            this.executeCommand(command);
+        });
+        this.engineMagicService
+            .interactiveCommands.pipe(filter(command => command.TaskTag === '0'))
+            .subscribe(command => {
+            GuiInteractiveExecutor.executeInteractiveCommand(null, command, this.overlayWindowService);
+        });
+    }
+    executeCommand(command) {
+        switch (command.CommandType) {
+            case CommandType.OPEN_FORM:
+                this.setComponent(command.str, command.stringList[0], command.stringList[1], command.Bool1);
+                break;
+            case CommandType.SET_IS_LOGGED_IN:
+                this.engineMagicService.setIsLoggedIn(command.Bool1);
+                break;
+            case CommandType.CLOSE_FORM:
+                if (this.RootComponent != null && command.str === this.RootComponentParameters.taskIdParam) {
+                    this.RootComponent = null;
+                    this.RootComponentParameters = {};
+                    this.changeDetectorRef.detectChanges();
+                }
+                else {
+                    this.overlayWindowService.close(command.str);
+                    this.changeDetectorRef.detectChanges();
+                }
+                break;
+            case CommandType.RELOAD_PAGE:
+                window.location.reload();
+                break;
+            case CommandType.SHOW_SPINNER:
+                if (this.showSpinner != command.Bool1) {
+                    this.showSpinner = command.Bool1;
+                    this.changeDetectorRef.detectChanges();
+                }
+                break;
+            case CommandType.EXIT_MAGIC:
+                if (this.exitMagicService)
+                    this.exitMagicService.exitMagic();
+                break;
+            case CommandType.SHOW_HTML_ERROR:
+                window.document.write(command.str);
+                break;
+        }
+    }
+}
+MagicShellComponent.ɵfac = function MagicShellComponent_Factory(t) { return new (t || MagicShellComponent)(i0.ɵɵdirectiveInject(i1.EngineMagicService), i0.ɵɵdirectiveInject(i2.ComponentListMagicService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i3.Title), i0.ɵɵdirectiveInject(i4.OverlayWindowService), i0.ɵɵdirectiveInject(i5.HttpClient), i0.ɵɵdirectiveInject(i6.CommandsCollectorMagicService), i0.ɵɵdirectiveInject(i7.ExitMagicService, 8)); };
+MagicShellComponent.ɵcmp = i0.ɵɵdefineComponent({ type: MagicShellComponent, selectors: [["magic-root"]], viewQuery: function MagicShellComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 7);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.rootMagicElementRef = _t.first);
+    } }, hostBindings: function MagicShellComponent_HostBindings(rf, ctx) { if (rf & 1) {
+        i0.ɵɵlistener("beforeunload", function MagicShellComponent_beforeunload_HostBindingHandler($event) { return ctx.onBeforeUnload($event); }, false, i0.ɵɵresolveWindow)("unload", function MagicShellComponent_unload_HostBindingHandler($event) { return ctx.onUnload($event); }, false, i0.ɵɵresolveWindow);
+    } }, inputs: { SpinnerTemplate: "SpinnerTemplate" }, features: [i0.ɵɵProvidersFeature([])], decls: 8, vars: 2, consts: [["magicRoot", ""], [3, "ndcDynamicComponent", "ndcDynamicInputs", 4, "ngIf"], ["magicViewContainerRef", ""], ["overlayWindowsContainer", ""], ["class", "spinner-background", 4, "ngIf"], ["defaultSpinner", ""], [3, "ndcDynamicComponent", "ndcDynamicInputs"], [1, "spinner-background"], [3, "ngTemplateOutlet"], [1, "mgSpinnerClass"]], template: function MagicShellComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", null, 0);
+        i0.ɵɵtemplate(2, MagicShellComponent_ndc_dynamic_2_Template, 1, 2, "ndc-dynamic", 1);
+        i0.ɵɵelement(3, "div", 2, 3);
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(5, MagicShellComponent_div_5_Template, 2, 1, "div", 4);
+        i0.ɵɵtemplate(6, MagicShellComponent_ng_template_6_Template, 1, 0, "ng-template", null, 5, i0.ɵɵtemplateRefExtractor);
+    } if (rf & 2) {
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngIf", ctx.RootComponent !== null);
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("ngIf", ctx.showSpinner);
+    } }, directives: [i8.NgIf, i9.DynamicComponent, i9.DynamicIoDirective, i10.MagicViewContainerRef, i8.NgTemplateOutlet], styles: [".mgSpinnerClass[_ngcontent-%COMP%]{border:10px solid #cccccc;border-top:10px solid black;border-radius:50%;position:fixed;margin:auto;top:0;right:0;bottom:0;left:0;width:100px;height:100px;animation:spin 2s linear infinite}.spinner-background[_ngcontent-%COMP%]{position:fixed;top:0;right:0;bottom:0;z-index:1000;left:0;opacity:.5}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MagicShellComponent, [{
+        type: Component,
+        args: [{
+                selector: 'magic-root',
+                providers: [],
+                template: `
+    <div #magicRoot>
+      <ndc-dynamic
+        *ngIf = "RootComponent !== null"
+        [ndcDynamicComponent]="RootComponent"
+        [ndcDynamicInputs]   ="RootComponentParameters">
+      </ndc-dynamic>
+
+      <div #overlayWindowsContainer magicViewContainerRef>
+      </div>
+    </div>
+
+    <div class="spinner-background" *ngIf="showSpinner">
+      <ng-container [ngTemplateOutlet]="SpinnerTemplate ? SpinnerTemplate:defaultSpinner"></ng-container>
+    </div>
+
+    <ng-template #defaultSpinner>
+      <div class="mgSpinnerClass"></div>
+    </ng-template>
+  `,
+                styles: [`
+    .mgSpinnerClass {
+      border: 10px solid #cccccc; /* Light grey */
+      border-top: 10px solid black; /* Blue */
+      border-radius: 50%;
+      position: fixed;
+      margin: auto;
+      top: 0;
+      right: 0;
+      bottom: 0;
+      left: 0;
+      width: 100px;
+      height: 100px;
+      animation: spin 2s linear infinite;
+    }
+    .spinner-background {
+      /* background fixed across whole screen */
+      position: fixed;
+      top: 0;
+      right: 0;
+      bottom: 0;
+      z-index: 1000;
+      left: 0;
+      opacity: 0.5;
+    }
+    @keyframes spin {
+      0% { transform: rotate(0deg); }
+      100% { transform: rotate(360deg); }
+    }
+  `]
+            }]
+    }], function () { return [{ type: i1.EngineMagicService }, { type: i2.ComponentListMagicService }, { type: i0.ChangeDetectorRef }, { type: i3.Title }, { type: i4.OverlayWindowService }, { type: i5.HttpClient }, { type: i6.CommandsCollectorMagicService }, { type: i7.ExitMagicService, decorators: [{
+                type: Optional
+            }] }]; }, { rootMagicElementRef: [{
+            type: ViewChild,
+            args: ['magicRoot', { static: true }]
+        }], SpinnerTemplate: [{
+            type: Input
+        }], onBeforeUnload: [{
+            type: HostListener,
+            args: ['window:beforeunload', ['$event']]
+        }], onUnload: [{
+            type: HostListener,
+            args: ['window:unload', ['$event']]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"magic-root.component.js","sourceRoot":"","sources":["../../../../../../projects/angular/src/ui/magic-root.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,YAAY,EACZ,KAAK,EACL,QAAQ,EACR,WAAW,EACX,SAAS,EAEV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAc,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,0CAA0C,CAAC;AACrF,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAExE,OAAO,EAAE,6BAA6B,EAAE,MAAM,8CAA8C,CAAC;AAC7F,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;;;;;;;;;;;;;;IAY5C,iCAIc;;;IAFZ,0DAAqC,oDAAA;;;IAQzC,8BAAoD;IAClD,2BAAmG;IACrG,iBAAM;;;;IADU,eAAqE;IAArE,wFAAqE;;;IAInF,yBAAkC;;AAkCxC,MAAM,OAAO,mBAAmB;IA4B9B,YAAsB,kBAAsC,EACtC,aAAuC,EACvC,iBAAoC,EACtC,YAAmB,EACnB,oBAA0C,EAC1C,UAAsB,EACtB,wBAAuD,EAC3C,gBAAkC;QAP5C,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,kBAAa,GAAb,aAAa,CAA0B;QACvC,sBAAiB,GAAjB,iBAAiB,CAAmB;QACtC,iBAAY,GAAZ,YAAY,CAAO;QACnB,yBAAoB,GAApB,oBAAoB,CAAsB;QAC1C,eAAU,GAAV,UAAU,CAAY;QACtB,6BAAwB,GAAxB,wBAAwB,CAA+B;QAC3C,qBAAgB,GAAhB,gBAAgB,CAAkB;QA/BlE,kBAAa,GAAe,IAAI,CAAC;QAajC,0BAAqB,GAAY,KAAK,CAAC;QAoBrC,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAOD,cAAc,CAAC,KAAK;QAClB,IAAG,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,EAC7C;YAEE,KAAK,CAAC,WAAW,GAAG,eAAe,CAAC;YACpC,OAAO,eAAe,CAAC;SACxB;aAED;YAEE,IAAI,CAAC,kBAAkB,CAAC,6BAA6B,EAAE,CAAC;YACxD,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;SACnC;IACH,CAAC;IAGD,QAAQ,CAAC,KAAK;QAEZ,IAAG,CAAC,IAAI,CAAC,qBAAqB;YAC5B,IAAI,CAAC,kBAAkB,CAAC,6BAA6B,EAAE,CAAC;IAC5D,CAAC;IAED,eAAe;QACb,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,8BAA8B,EAAE,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;QAC5G,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5D,CAAC;IAED,mBAAmB,CAAC,KAAuB;QACzC,IAAI,CAAC,8BAA8B,GAAG,KAAK,CAAC;IAC9C,CAAC;IAKD,UAAU;QACR,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAKM,QAAQ;QACb,MAAM,QAAQ,GAAW,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;QAClD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAE,QAAQ,CAAE,CAAC;IACzC,CAAC;IASO,YAAY,CAAC,QAAgB,EAAE,MAAc,EAAE,eAAuB,EAAE,OAAgB;QAC9F,IAAI,CAAC,wBAAwB,CAAC,eAAe,EAAE,CAAC;QAEhD,IAAG,OAAO,EAAE;YACV,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC;SACnE;aACI;YACH,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;YAC/D,IAAI,CAAC,uBAAuB,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe,EAAE,CAAC;SAC1F;QACD,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;IACzC,CAAC;IAKD,kBAAkB;QAChB,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,IAAI,CACrC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,KAAK,GAAG,CAAC,CAAC;aAC1C,SAAS,CAAC,OAAO,CAAC,EAAE;YACnB,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;QACL,IAAI,CAAC,kBAAkB;aACpB,mBAAmB,CAAC,IAAI,CACzB,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,KAAK,GAAG,CAAC,CAAC;aAC1C,SAAS,CAAC,OAAO,CAAC,EAAE;YACnB,sBAAsB,CAAC,yBAAyB,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC7F,CAAC,CAAC,CAAC;IACP,CAAC;IAMD,cAAc,CAAC,OAAmB;QAChC,QAAQ,OAAO,CAAC,WAAW,EAAE;YAC3B,KAAK,WAAW,CAAC,SAAS;gBACtB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC5F,MAAM;YAEV,KAAK,WAAW,CAAC,gBAAgB;gBAC/B,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACrD,MAAM;YAER,KAAK,WAAW,CAAC,UAAU;gBACzB,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,IAAI,OAAO,CAAC,GAAG,KAAK,IAAI,CAAC,uBAAuB,CAAC,WAAW,EAAE;oBAC1F,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;oBAC1B,IAAI,CAAC,uBAAuB,GAAG,EAAE,CAAC;oBAElC,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;iBACxC;qBACI;oBACH,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;oBAC7C,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;iBACxC;gBACD,MAAM;YAER,KAAK,WAAW,CAAC,WAAW;gBAC1B,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;gBACzB,MAAM;YAER,KAAK,WAAW,CAAC,YAAY;gBAC3B,IAAI,IAAI,CAAC,WAAW,IAAI,OAAO,CAAC,KAAK,EAAE;oBACrC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC;oBACjC,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;iBACxC;gBACD,MAAM;YAER,KAAK,WAAW,CAAC,UAAU;gBACzB,IAAI,IAAI,CAAC,gBAAgB;oBACvB,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC;gBACpC,MAAM;YAER,KAAK,WAAW,CAAC,eAAe;gBAC9B,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;gBACnC,MAAM;SACT;IACH,CAAC;;sFAhLU,mBAAmB;wDAAnB,mBAAmB;;;;;;oHAAnB,0BAAsB,kHAAtB,oBAAgB;0FAtDhB,EAEV;QAEC,oCAAgB;QACd,oFAIc;QAEd,4BACM;QACR,iBAAM;QAEN,oEAEM;QAEN,qHAEc;;QAfT,eAA8B;QAA9B,iDAA8B;QASF,eAAiB;QAAjB,sCAAiB;;uFAuCzC,mBAAmB;cAxD/B,SAAS;eAAC;gBACT,QAAQ,EAAE,YAAY;gBACtB,SAAS,EAAE,EAEV;gBACD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;GAmBT;gBACD,MAAM,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BR,CAAC;aACH;;sBAoCc,QAAQ;wBAvBqB,mBAAmB;kBAA5D,SAAS;mBAAC,WAAW,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;YAE/B,eAAe;kBAAvB,KAAK;YAgCN,cAAc;kBADb,YAAY;mBAAC,qBAAqB,EAAE,CAAC,QAAQ,CAAC;YAiB/C,QAAQ;kBADP,YAAY;mBAAC,eAAe,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["import {\r\n  AfterViewInit,\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  HostListener,\r\n  Input,\r\n  Optional,\r\n  TemplateRef,\r\n  ViewChild,\r\n  ViewContainerRef\r\n} from '@angular/core';\r\nimport { CommandType, GuiCommand } from '@magic-xpa/gui';\r\nimport { Title } from '@angular/platform-browser';\r\nimport { EngineMagicService } from '../services/engine.magic.service';\r\nimport { ComponentListMagicService } from '../services/component-list.magic.service';\r\nimport { GuiInteractiveExecutor } from './GuiInteractiveExecutor';\r\nimport { filter } from 'rxjs/operators';\r\nimport { ExitMagicService } from '../services/exit.magic.service';\r\nimport { OverlayWindowService } from '../services/OverlayWindowService';\r\nimport { IMagicViewContainerRef } from '../..';\r\nimport { CommandsCollectorMagicService } from '../services/commands-collector.magic.service';\r\nimport { HttpClient } from '@angular/common/http';\r\n\r\n/**\r\n * Root Magic component\r\n */\r\n@Component({\r\n  selector: 'magic-root',\r\n  providers: [\r\n   // ExitMagicService\r\n  ],\r\n  template: `\r\n    <div #magicRoot>\r\n      <ndc-dynamic\r\n        *ngIf = \"RootComponent !== null\"\r\n        [ndcDynamicComponent]=\"RootComponent\"\r\n        [ndcDynamicInputs]   =\"RootComponentParameters\">\r\n      </ndc-dynamic>\r\n\r\n      <div #overlayWindowsContainer magicViewContainerRef>\r\n      </div>\r\n    </div>\r\n\r\n    <div class=\"spinner-background\" *ngIf=\"showSpinner\">\r\n      <ng-container [ngTemplateOutlet]=\"SpinnerTemplate ? SpinnerTemplate:defaultSpinner\"></ng-container>\r\n    </div>\r\n\r\n    <ng-template #defaultSpinner>\r\n      <div class=\"mgSpinnerClass\"></div>\r\n    </ng-template>\r\n  `,\r\n  styles: [`\r\n    .mgSpinnerClass {\r\n      border: 10px solid #cccccc; /* Light grey */\r\n      border-top: 10px solid black; /* Blue */\r\n      border-radius: 50%;\r\n      position: fixed;\r\n      margin: auto;\r\n      top: 0;\r\n      right: 0;\r\n      bottom: 0;\r\n      left: 0;\r\n      width: 100px;\r\n      height: 100px;\r\n      animation: spin 2s linear infinite;\r\n    }\r\n    .spinner-background {\r\n      /* background fixed across whole screen */\r\n      position: fixed;\r\n      top: 0;\r\n      right: 0;\r\n      bottom: 0;\r\n      z-index: 1000;\r\n      left: 0;\r\n      opacity: 0.5;\r\n    }\r\n    @keyframes spin {\r\n      0% { transform: rotate(0deg); }\r\n      100% { transform: rotate(360deg); }\r\n    }\r\n  `]\r\n})\r\nexport class MagicShellComponent implements AfterViewInit, IMagicViewContainerRef {\r\n  /**\r\n   * Root component to be displayed in the window\r\n   */\r\n  RootComponent : Component = null;\r\n  /**\r\n   * parameters for the Root Component\r\n   */\r\n  RootComponentParameters : any;\r\n\r\n  overlayWindowsContainerViewRef: ViewContainerRef;\r\n\r\n  @ViewChild('magicRoot', { static: true }) rootMagicElementRef: ElementRef;\r\n\r\n  @Input() SpinnerTemplate: TemplateRef<any>;\r\n\r\n  showSpinner: boolean;\r\n  magicEngineTerminated: boolean = false;\r\n\r\n  /**\r\n   *\r\n   * @param magic Magic's service\r\n   * @param componentList Magic component list\r\n   * @param changeDetectorRef Changes detector\r\n   * @param titleService Title setting service\r\n   * @param httpClient The native httpClient instance\r\n   * @param exitMagicService Magic exit service\r\n   */\r\n  constructor(protected engineMagicService: EngineMagicService,\r\n              protected componentList:ComponentListMagicService,\r\n              protected changeDetectorRef: ChangeDetectorRef,\r\n              private titleService: Title,\r\n              private overlayWindowService: OverlayWindowService,\r\n              private httpClient: HttpClient,\r\n              private pendingCommandsCollector: CommandsCollectorMagicService,\r\n              @Optional()  public exitMagicService: ExitMagicService) {\r\n\r\n    this.initialize();\r\n    this.setTitle();\r\n  }\r\n\r\n  /**\r\n   * Before-unload event listener\r\n   * @param event\r\n   */\r\n  @HostListener('window:beforeunload', ['$event'])\r\n  onBeforeUnload(event) {\r\n    if(this.engineMagicService.TransCacheExists())\r\n    {\r\n      // Show the confirmation box before unloading the browser\r\n      event.returnValue = 'Are you sure?';\r\n      return 'Are you sure?';\r\n    }\r\n    else\r\n    {\r\n      // terminate the magic server context using fetch API with keep-alive\r\n      this.engineMagicService.TerminateContextUsingFetchAPI();\r\n      this.magicEngineTerminated = true;\r\n    }\r\n  }\r\n\r\n  @HostListener('window:unload', ['$event'])\r\n  onUnload(event) {\r\n    // Chrome provides an opportunity to terminate the context after user approves the browser unload alert\r\n    if(!this.magicEngineTerminated)\r\n      this.engineMagicService.TerminateContextUsingFetchAPI();\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    this.overlayWindowService.init(this.overlayWindowsContainerViewRef, this.rootMagicElementRef.nativeElement);\r\n    this.engineMagicService.startMagicEngine(this.httpClient);\r\n  }\r\n\r\n  setViewContainerRef(vcRef: ViewContainerRef){\r\n    this.overlayWindowsContainerViewRef = vcRef;\r\n  }\r\n\r\n  /**\r\n   * Initialization of Magic mechanisms\r\n   */\r\n  initialize() {\r\n    this.registerUICommands();\r\n  }\r\n\r\n  /**\r\n   * Set the title\r\n   */\r\n  public setTitle( ) {\r\n    const newTitle: string = this.componentList.title;\r\n    this.titleService.setTitle( newTitle );\r\n  }\r\n\r\n  /**\r\n   * Set the component according to requested form\r\n   * @param formName Name of the form to open\r\n   * @param taskId Id of opening task\r\n   * @param taskDescription TODO\r\n   * @param isModal whether modal window is being opened\r\n   */\r\n  private setComponent(formName: string, taskId: string, taskDescription: string, isModal: boolean) {\r\n    this.pendingCommandsCollector.startCollecting();\r\n\r\n    if(isModal) {\r\n      this.overlayWindowService.open(formName, taskId, taskDescription);\r\n    }\r\n    else {\r\n      this.RootComponent = this.componentList.getComponent(formName);\r\n      this.RootComponentParameters = { taskIdParam: taskId, taskDescription: taskDescription };\r\n    }\r\n    this.changeDetectorRef.detectChanges();\r\n  }\r\n\r\n  /**\r\n   * @ignore\r\n   */\r\n  registerUICommands() {\r\n    this.engineMagicService.refreshDom.pipe(\r\n      filter(command => command.TaskTag === '0'))\r\n      .subscribe(command => {\r\n        this.executeCommand(command);\r\n      });\r\n    this.engineMagicService\r\n      .interactiveCommands.pipe(\r\n      filter(command => command.TaskTag === '0'))\r\n      .subscribe(command => {\r\n        GuiInteractiveExecutor.executeInteractiveCommand(null, command, this.overlayWindowService);\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Execute commands received from the Magic WebClient engine\r\n   * @param command\r\n   */\r\n  executeCommand(command: GuiCommand): void {\r\n    switch (command.CommandType) {\r\n      case CommandType.OPEN_FORM:\r\n          this.setComponent(command.str, command.stringList[0], command.stringList[1], command.Bool1);\r\n          break;\r\n\r\n      case CommandType.SET_IS_LOGGED_IN:\r\n        this.engineMagicService.setIsLoggedIn(command.Bool1);\r\n        break;\r\n\r\n      case CommandType.CLOSE_FORM:\r\n        if (this.RootComponent != null && command.str === this.RootComponentParameters.taskIdParam) {\r\n          this.RootComponent = null;\r\n          this.RootComponentParameters = {};\r\n\r\n          this.changeDetectorRef.detectChanges();\r\n        }\r\n        else { // Close modal window\r\n          this.overlayWindowService.close(command.str);\r\n          this.changeDetectorRef.detectChanges();\r\n        }\r\n        break;\r\n\r\n      case CommandType.RELOAD_PAGE:\r\n        window.location.reload();\r\n        break;\r\n\r\n      case CommandType.SHOW_SPINNER:\r\n        if (this.showSpinner != command.Bool1) {\r\n          this.showSpinner = command.Bool1;\r\n          this.changeDetectorRef.detectChanges();\r\n        }\r\n        break;\r\n\r\n      case CommandType.EXIT_MAGIC:\r\n        if (this.exitMagicService)\r\n          this.exitMagicService.exitMagic();\r\n        break;\r\n\r\n      case CommandType.SHOW_HTML_ERROR:\r\n        window.document.write(command.str);\r\n        break;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/src/ui/mgerror.magic.component.mjs

@@ -0,0 +1,120 @@
+import { ChangeDetectorRef, Component, ElementRef, Input, ViewChild } from "@angular/core";
+import { AccessorMagicService } from "../services/accessor.magic.service";
+import { TaskMagicService } from "../services/task.magics.service";
+import { isUndefined } from "@magic-xpa/mscorelib";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/task.magics.service";
+import * as i2 from "../services/accessor.magic.service";
+import * as i3 from "@angular/common";
+const _c0 = ["customContent"];
+function ErrorMagicComponent_div_0_span_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span");
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", ctx_r2.mgService.getErrMsg(ctx_r2.id, ctx_r2.rowId), " ");
+} }
+function ErrorMagicComponent_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "div");
+    i0.ɵɵelementStart(1, "div", null, 1);
+    i0.ɵɵprojection(3);
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(4, ErrorMagicComponent_div_0_span_4_Template, 2, 1, "span", 0);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(4);
+    i0.ɵɵproperty("ngIf", ctx_r0.defaultDisplay);
+} }
+const _c1 = ["*"];
+export class ErrorMagicComponent {
+    constructor(_task, mgService, changeDetectorRef) {
+        this._task = _task;
+        this.mgService = mgService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.defaultDisplay = true;
+        this.rowId = "0";
+    }
+    set magic(val) {
+        this.id = val;
+    }
+    ;
+    set rowId1(val) {
+        this.rowId = val;
+    }
+    ;
+    set CustomContent(innerComponent) {
+        this.defaultDisplay = innerComponent == undefined || this.isEmpty(innerComponent.nativeElement);
+        this.changeDetectorRef.detectChanges();
+    }
+    ;
+    isEmpty(element) {
+        const nodes = element.childNodes;
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes.item(i);
+            if (node.nodeType !== 8 && nodes.item(i).textContent.trim().length !== 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    HasErrors(id) {
+        if (!isUndefined(id)) {
+            let control = this._task.getFormControl(this.rowId, id);
+            if (control !== null) {
+                if (control.dirty && (control.hasError('pattern') || control.hasError('required') ||
+                    control.hasError('rangevalidator') || control.hasError('maxlength') || control.hasError('max')))
+                    return true;
+                if (control.touched && control.hasError('required'))
+                    return true;
+                if (this._task.Records.list[this.rowId] && this._task.Records.list[this.rowId].getControlMetadata(id)) {
+                    let controlMetadata = this._task.Records.list[this.rowId].getControlMetadata(id);
+                    for (let customValidator of controlMetadata.customValidators.keys()) {
+                        if (control.hasError(customValidator))
+                            return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}
+ErrorMagicComponent.ɵfac = function ErrorMagicComponent_Factory(t) { return new (t || ErrorMagicComponent)(i0.ɵɵdirectiveInject(i1.TaskMagicService), i0.ɵɵdirectiveInject(i2.AccessorMagicService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); };
+ErrorMagicComponent.ɵcmp = i0.ɵɵdefineComponent({ type: ErrorMagicComponent, selectors: [["mgError"]], viewQuery: function ErrorMagicComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.CustomContent = _t.first);
+    } }, inputs: { magic: "magic", rowId1: ["rowId", "rowId1"] }, ngContentSelectors: _c1, decls: 1, vars: 1, consts: [[4, "ngIf"], ["customContent", ""]], template: function ErrorMagicComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵprojectionDef();
+        i0.ɵɵtemplate(0, ErrorMagicComponent_div_0_Template, 5, 1, "div", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("ngIf", ctx.HasErrors(ctx.id));
+    } }, directives: [i3.NgIf], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorMagicComponent, [{
+        type: Component,
+        args: [{
+                selector: 'mgError',
+                template: `<div *ngIf="HasErrors(id)">
+    <div #customContent>
+      <ng-content></ng-content>
+    </div>
+     <span *ngIf="defaultDisplay">
+      {{mgService.getErrMsg(id, rowId)}} 
+    </span>
+    </div>
+`
+            }]
+    }], function () { return [{ type: i1.TaskMagicService }, { type: i2.AccessorMagicService }, { type: i0.ChangeDetectorRef }]; }, { magic: [{
+            type: Input,
+            args: ['magic']
+        }], rowId1: [{
+            type: Input,
+            args: ['rowId']
+        }], CustomContent: [{
+            type: ViewChild,
+            args: ['customContent', { static: false }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/ui/pipes/date.magic.pipe.mjs

@@ -0,0 +1,105 @@
+import { Pipe } from '@angular/core';
+import { DatePipe } from '@angular/common';
+import { TaskMagicService } from '../../services/task.magics.service';
+import { StringBuilder, isNullOrUndefined } from "@magic-xpa/mscorelib";
+import { PICInterface } from "@magic-xpa/utils";
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/task.magics.service";
+export class Constants {
+}
+Constants.DATE_FMT = 'dd/MMM/yyyy';
+export class DateMagicPipe extends DatePipe {
+    constructor(_task) {
+        super('en-US');
+        this._task = _task;
+    }
+    transform(value, controlId) {
+        let mask = this._task.GetControlPictureMask(controlId).getMask();
+        let formatStr = null;
+        let mgDateFormatter = new MgDateFormatter();
+        if (!isNullOrUndefined(value) && mask !== null) {
+            formatStr = mgDateFormatter.ConvertMgDateFormatToAngular(mask);
+            if (formatStr != null && this._task.isTableControl(controlId)) {
+                if (this._task.mgInputDateFormat == null)
+                    this._task.mgInputDateFormat = formatStr;
+                else
+                    formatStr = this._task.mgInputDateFormat;
+            }
+            return super.transform(value, formatStr);
+        }
+        else
+            value = "";
+        return value;
+    }
+}
+DateMagicPipe.ɵfac = function DateMagicPipe_Factory(t) { return new (t || DateMagicPipe)(i0.ɵɵdirectiveInject(i1.TaskMagicService, 16)); };
+DateMagicPipe.ɵpipe = i0.ɵɵdefinePipe({ name: "magicDate", type: DateMagicPipe, pure: true });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DateMagicPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'magicDate'
+            }]
+    }], function () { return [{ type: i1.TaskMagicService }]; }, null); })();
+export class MgDateFormatter {
+    ConvertMgDateFormatToAngular(mgDateMask) {
+        let formatStr = new StringBuilder();
+        if (mgDateMask !== null) {
+            for (let i = 0; i < mgDateMask.length;) {
+                switch (mgDateMask.charCodeAt(i)) {
+                    case PICInterface.PIC_YYYY:
+                        formatStr.Append('yyyy');
+                        i += 4;
+                        break;
+                    case PICInterface.PIC_MMD:
+                        formatStr.Append('MM');
+                        i += 2;
+                        break;
+                    case PICInterface.PIC_YY:
+                        formatStr.Append('yy');
+                        i += 2;
+                        break;
+                    case PICInterface.PIC_MMM:
+                        {
+                            let cnt = 0;
+                            for (; i < mgDateMask.length; i++)
+                                if (mgDateMask.charCodeAt(i) == PICInterface.PIC_MMM)
+                                    cnt++;
+                                else
+                                    break;
+                            if (cnt == 3)
+                                formatStr.Append('MMM');
+                            if (cnt > 3)
+                                formatStr.Append('MMMM');
+                        }
+                        break;
+                    case PICInterface.PIC_DD:
+                        formatStr.Append('dd');
+                        i += 2;
+                        break;
+                    case PICInterface.PIC_WWW:
+                        {
+                            let cnt = 0;
+                            for (; i < mgDateMask.length; i++)
+                                if (mgDateMask.charCodeAt(i) == PICInterface.PIC_WWW)
+                                    cnt++;
+                                else
+                                    break;
+                            if (cnt == 3)
+                                formatStr.Append('EEE');
+                            if (cnt > 3)
+                                formatStr.Append('EEEE');
+                        }
+                        break;
+                    default:
+                        formatStr.Append(mgDateMask.charAt(i));
+                        i++;
+                        break;
+                }
+            }
+            return formatStr.ToString();
+        }
+        else
+            return "dd-mm-yyyy";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date.magic.pipe.js","sourceRoot":"","sources":["../../../../../../../projects/angular/src/ui/pipes/date.magic.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\r\nimport { DatePipe } from '@angular/common';\r\nimport {TaskMagicService} from '../../services/task.magics.service';\r\nimport {StringBuilder, isNullOrUndefined} from \"@magic-xpa/mscorelib\"\r\nimport {PICInterface} from \"@magic-xpa/utils\"\r\n\r\n\r\n/**\r\n * @ignore\r\n */\r\nexport class Constants {\r\n  static readonly DATE_FMT = 'dd/MMM/yyyy';\r\n}\r\n\r\n/**\r\n * @ignore\r\n */\r\n@Pipe({\r\n  name: 'magicDate'\r\n})\r\nexport class DateMagicPipe extends DatePipe implements PipeTransform {\r\n\r\n  constructor(protected _task: TaskMagicService) {\r\n    super('en-US');\r\n\r\n    }\r\n\r\n  transform(value: any, controlId: string): any {\r\n\r\n    let mask: string = this._task.GetControlPictureMask (controlId).getMask();\r\n    let formatStr: string = null;\r\n    let mgDateFormatter = new MgDateFormatter();\r\n    if (!isNullOrUndefined(value) && mask !== null) {\r\n      formatStr = mgDateFormatter.ConvertMgDateFormatToAngular (mask);\r\n      // If control is label control of table, due to query mode, then save the format here.\r\n      if (formatStr != null && this._task.isTableControl(controlId)) {\r\n        if (this._task.mgInputDateFormat == null)\r\n          this._task.mgInputDateFormat = formatStr;\r\n        else\r\n          formatStr = this._task.mgInputDateFormat;\r\n      }\r\n      return super.transform(value, formatStr);\r\n    }\r\n    else\r\n      value = \"\";\r\n\r\n    return value;\r\n  }\r\n}\r\n\r\nexport  class MgDateFormatter {\r\n\r\n  ConvertMgDateFormatToAngular(mgDateMask: string) : string\r\n  {\r\n    let formatStr: StringBuilder = new StringBuilder ();\r\n\r\n    if (mgDateMask !== null) {\r\n      for (let i: number = 0; i < mgDateMask.length;) {\r\n        switch (mgDateMask.charCodeAt(i)) {\r\n          case PICInterface.PIC_YYYY:\r\n            formatStr.Append('yyyy');\r\n            i += 4;\r\n            break;\r\n          case PICInterface.PIC_MMD:\r\n            formatStr.Append('MM');\r\n            i += 2;\r\n            break;\r\n          case PICInterface.PIC_YY:\r\n            formatStr.Append('yy');\r\n            i += 2;\r\n            break;\r\n          case PICInterface.PIC_MMM:\r\n          {\r\n            let cnt = 0;\r\n            for  (;i < mgDateMask.length; i++)\r\n              if (mgDateMask.charCodeAt(i) == PICInterface.PIC_MMM)\r\n                cnt++;\r\n              else\r\n                break;\r\n\r\n            if (cnt == 3)\r\n              formatStr.Append('MMM');\r\n            if (cnt > 3)\r\n              formatStr.Append('MMMM');\r\n          }\r\n\r\n            break;\r\n          case PICInterface.PIC_DD:\r\n            formatStr.Append('dd');\r\n            i += 2;\r\n\r\n            break;\r\n\r\n          case PICInterface.PIC_WWW: {\r\n            let cnt = 0;\r\n            for  (;i < mgDateMask.length; i++)\r\n              if (mgDateMask.charCodeAt(i) == PICInterface.PIC_WWW)\r\n                cnt++;\r\n              else\r\n                break;\r\n\r\n            if (cnt == 3)\r\n              formatStr.Append('EEE');\r\n            if (cnt > 3)\r\n              formatStr.Append('EEEE');\r\n            }\r\n\r\n            break;\r\n\r\n          default:\r\n            formatStr.Append(mgDateMask.charAt(i));\r\n            i++;\r\n            break;\r\n        }\r\n      }\r\n      return formatStr.ToString();\r\n    }\r\n    else\r\n      return \"dd-mm-yyyy\"; // return default format.\r\n\r\n  }\r\n}\r\n"]}

package/{esm2015/src/ui/pipes/time.magic.pipe.js → esm2020/src/ui/pipes/time.magic.pipe.mjs}

@@ -40,12 +40,12 @@ export class TimeMagicPipe extends DatePipe {
         return value;
     }
 }
-TimeMagicPipe.ɵfac = function TimeMagicPipe_Factory(t) { return new (t || TimeMagicPipe)(i0.ɵɵdirectiveInject(i1.TaskMagicService)); };
+TimeMagicPipe.ɵfac = function TimeMagicPipe_Factory(t) { return new (t || TimeMagicPipe)(i0.ɵɵdirectiveInject(i1.TaskMagicService, 16)); };
 TimeMagicPipe.ɵpipe = i0.ɵɵdefinePipe({ name: "magicTime", type: TimeMagicPipe, pure: true });
-(function () { i0.ɵsetClassMetadata(TimeMagicPipe, [{
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TimeMagicPipe, [{
         type: Pipe,
         args: [{
                 name: 'magicTime'
             }]
     }], function () { return [{ type: i1.TaskMagicService }]; }, null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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