mmhglobal-dynamicform 2.0.0-beta.2 → 2.0.0-beta.21

package/esm2020/lib/services/signalr.service.mjs

@@ -0,0 +1,126 @@
+import { Injectable } from "@angular/core";
+import { HubConnectionBuilder, LogLevel } from "@microsoft/signalr";
+import { MessagePackHubProtocol } from "@microsoft/signalr-protocol-msgpack";
+import { map, Subject } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "mmhglobal-zcore";
+export class SignalrEvent {
+}
+export class PushChangeEvent {
+}
+export class SignalrService {
+    constructor(zone, authService, zcoreService) {
+        this.zone = zone;
+        this.authService = authService;
+        this.zcoreService = zcoreService;
+        this.environment = null;
+        this.environment = this.zcoreService.getEnvironment();
+        const errorSubject = new Subject();
+        this.createHubConnection();
+        this.connection.onreconnecting(error => this.zone.run(() => errorSubject.next(error)));
+    }
+    get hubConnectionOptions() {
+        return {
+            headers: SignalRHeader,
+            // transport: HttpTransportType.WebSockets,
+            accessTokenFactory: () => {
+                return this.authService.e1Token.access_token;
+            }
+        };
+    }
+    get retryPolicy() {
+        return {
+            nextRetryDelayInMilliseconds: retryContext => {
+                if (retryContext.elapsedMilliseconds < 60000) {
+                    return Math.random() * 10000;
+                }
+                else {
+                    return 30000;
+                }
+            }
+        };
+    }
+    async createHubConnection() {
+        this.eventSubject = new Subject();
+        const hubEndPoint = this.environment.signalRUrl;
+        this.connection = new HubConnectionBuilder()
+            .withUrl(hubEndPoint + '/signalr', this.hubConnectionOptions)
+            .withHubProtocol(new MessagePackHubProtocol())
+            .withAutomaticReconnect(this.retryPolicy)
+            .configureLogging(LogLevel.Information)
+            .build();
+        this.connection.start();
+        this.connection.on('onEvent', (event) => {
+            switch (event.Name) {
+                case 'ErrorAtHub':
+                    console.warn('Error At Hub:', event.Payload);
+                    break;
+                case 'LoggingAtHub':
+                    console.warn('Logging At Hub:', event.Payload);
+                    break;
+                default:
+                    this.zone.run(() => this.eventSubject.next(event));
+                    break;
+            }
+        });
+        this.connection.onreconnecting(error => this.handleOnReconnecting(error));
+        this.connection.onreconnected(connectionId => this.handleOnReconnected(connectionId));
+        this.connection.onclose(error => this.handleOnClose(error));
+        this.event$ = this.eventSubject.asObservable();
+    }
+    handleOnReconnecting(error) {
+        console.log('Hub connection started reconnecting due to an error: ', error);
+    }
+    handleOnReconnected(connectionId) {
+        console.log('Hub connection successfully reconnected. ConnectionId is now: ', connectionId);
+    }
+    handleOnClose(error) {
+        if (error === null) {
+            console.log('Hub connection closed without error.', error);
+        }
+        else {
+            console.log('Hub connection closed due to an error: ', error);
+        }
+    }
+    getEvent() {
+        return this.event$.pipe(map(event => {
+            return {
+                name: event.Name,
+                payload: event.Payload
+            };
+        }));
+    }
+    getConnectionId() {
+        return this.connection.connectionId;
+    }
+    joinGroup(groupName) {
+        this.connection.invoke("JoinGroup", groupName);
+    }
+    removeFromGroup(groupName) {
+        this.connection.invoke("RemoveFromGroup", groupName);
+    }
+    sendToClientGroup(groupsToSend, serviceName, events) {
+        this.connection.invoke("SendToClientGroup", groupsToSend, serviceName, events);
+    }
+    sendToClientUser(userToSend, serviceName, events) {
+        this.connection.invoke("SendToClientUser", userToSend, serviceName, events);
+    }
+    sendToAllClients(serviceName, events) {
+        this.connection.invoke("SendToAllClients", serviceName, events);
+    }
+    sendToCaller(serviceName, events) {
+        this.connection.invoke("SendToCaller", serviceName, events);
+    }
+}
+SignalrService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: SignalrService, deps: [{ token: i0.NgZone }, { token: i1.AuthService }, { token: i1.ZCoreService }], target: i0.ɵɵFactoryTarget.Injectable });
+SignalrService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: SignalrService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: SignalrService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.AuthService }, { type: i1.ZCoreService }]; } });
+export const SignalRHeader = {
+    SignalRKey: "3D36C63093B75A091E116182BE91FFB99D53192365C6222979587514E6F65994"
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signalr.service.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/services/signalr.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAU,MAAM,eAAe,CAAC;AACnD,OAAO,EAAoC,oBAAoB,EAAwC,QAAQ,EAAkB,MAAM,oBAAoB,CAAC;AAC5J,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;;;AAIhD,MAAM,OAAO,YAAY;CAGxB;AAED,MAAM,OAAO,eAAe;CAG3B;AAMD,MAAM,OAAO,cAAc;IAMzB,YACU,IAAY,EACZ,WAAwB,EACxB,YAA0B;QAF1B,SAAI,GAAJ,IAAI,CAAQ;QACZ,gBAAW,GAAX,WAAW,CAAa;QACxB,iBAAY,GAAZ,YAAY,CAAc;QAL7B,gBAAW,GAAQ,IAAI,CAAC;QAQ7B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;QACtD,MAAM,YAAY,GAAG,IAAI,OAAO,EAAO,CAAC;QACxC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAE3B,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CACrC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC;IAED,IAAc,oBAAoB;QAChC,OAAO;YACL,OAAO,EAAE,aAAa;YACtB,2CAA2C;YAC3C,kBAAkB,EAAE,GAAG,EAAE;gBACvB,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC;YAC/C,CAAC;SACF,CAAC;IACJ,CAAC;IAED,IAAc,WAAW;QACvB,OAAO;YACL,4BAA4B,EAAE,YAAY,CAAC,EAAE;gBAC3C,IAAI,YAAY,CAAC,mBAAmB,GAAG,KAAK,EAAE;oBAC5C,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC;iBAC9B;qBAAM;oBACL,OAAO,KAAK,CAAC;iBACd;YACH,CAAC;SACF,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,mBAAmB;QACvB,IAAI,CAAC,YAAY,GAAG,IAAI,OAAO,EAAgB,CAAC;QAEhD,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC;QAChD,IAAI,CAAC,UAAU,GAAG,IAAI,oBAAoB,EAAE;aACzC,OAAO,CAAC,WAAW,GAAG,UAAU,EAAE,IAAI,CAAC,oBAAoB,CAAC;aAC5D,eAAe,CAAC,IAAI,sBAAsB,EAAE,CAAC;aAC7C,sBAAsB,CAAC,IAAI,CAAC,WAAW,CAAC;aACxC,gBAAgB,CAAC,QAAQ,CAAC,WAAW,CAAC;aACtC,KAAK,EAAE,CAAC;QAEX,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QAExB,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,KAAmB,EAAE,EAAE;YACpD,QAAQ,KAAK,CAAC,IAAI,EAAE;gBAClB,KAAK,YAAY;oBACf,OAAO,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;oBAC7C,MAAM;gBACR,KAAK,cAAc;oBACjB,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;oBAC/C,MAAM;gBACR;oBACE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;oBACnD,MAAM;aACT;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1E,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC,CAAC;QACtF,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;QAE5D,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;IACjD,CAAC;IAEO,oBAAoB,CAAC,KAAY;QACvC,OAAO,CAAC,GAAG,CAAC,uDAAuD,EAAE,KAAK,CAAC,CAAC;IAC9E,CAAC;IAEO,mBAAmB,CAAC,YAAoB;QAC9C,OAAO,CAAC,GAAG,CAAC,gEAAgE,EAAE,YAAY,CAAC,CAAC;IAC9F,CAAC;IAEO,aAAa,CAAC,KAAY;QAChC,IAAG,KAAK,KAAK,IAAI,EAAC;YAChB,OAAO,CAAC,GAAG,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;SAC5D;aACG;YACF,OAAO,CAAC,GAAG,CAAC,yCAAyC,EAAE,KAAK,CAAC,CAAC;SAC/D;IACH,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YAClC,OAAwB;gBACtB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,OAAO,EAAE,KAAK,CAAC,OAAO;aACvB,CAAA;QACH,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAED,eAAe;QACb,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;IACtC,CAAC;IAED,SAAS,CAAC,SAAiB;QACzB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IACjD,CAAC;IAED,eAAe,CAAC,SAAiB;QAC/B,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAA;IACtD,CAAC;IAED,iBAAiB,CAAC,YAAsB,EAAE,WAAmB,EAAE,MAAW;QACxE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,mBAAmB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IACjF,CAAC;IAED,gBAAgB,CAAC,UAAkB,EAAE,WAAmB,EAAE,MAAW;QACnE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,kBAAkB,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IAC9E,CAAC;IAED,gBAAgB,CAAC,WAAmB,EAAE,MAAW;QAC/C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,kBAAkB,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IAClE,CAAC;IAED,YAAY,CAAC,WAAmB,EAAE,MAAW;QAC3C,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,cAAc,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IAC9D,CAAC;;4GAhIU,cAAc;gHAAd,cAAc,cAHb,MAAM;4FAGP,cAAc;kBAJ1B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;AAqID,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,UAAU,EAAE,kEAAkE;CAC7D,CAAA","sourcesContent":["import { Injectable, NgZone } from \"@angular/core\";\r\nimport { HttpTransportType, HubConnection, HubConnectionBuilder, IHttpConnectionOptions, IRetryPolicy, LogLevel, MessageHeaders } from \"@microsoft/signalr\";\r\nimport { MessagePackHubProtocol } from \"@microsoft/signalr-protocol-msgpack\";\r\nimport { map, Observable, Subject } from \"rxjs\";\r\nimport { AuthService, ZCoreService } from \"mmhglobal-zcore\";\r\n\r\n\r\nexport class SignalrEvent {\r\n  Name: string;\r\n  Payload: any;\r\n}\r\n\r\nexport class PushChangeEvent {\r\n  name: string;\r\n  payload: any;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\n\r\nexport class SignalrService {\r\n  private connection: HubConnection;\r\n  private eventSubject: Subject<SignalrEvent>;\r\n  private event$: Observable<SignalrEvent>; \r\n  public environment: any = null;\r\n\r\n  constructor(\r\n    private zone: NgZone,\r\n    private authService: AuthService,\r\n    private zcoreService: ZCoreService,\r\n  ) {\r\n\r\n    this.environment = this.zcoreService.getEnvironment();\r\n    const errorSubject = new Subject<any>();\r\n    this.createHubConnection();\r\n\r\n    this.connection.onreconnecting(error =>\r\n      this.zone.run(() => errorSubject.next(error)));\r\n  }\r\n\r\n  protected get hubConnectionOptions(): IHttpConnectionOptions {\r\n    return {\r\n      headers: SignalRHeader,\r\n      // transport: HttpTransportType.WebSockets,\r\n      accessTokenFactory: () => {\r\n        return this.authService.e1Token.access_token;\r\n      }\r\n    };\r\n  }\r\n\r\n  protected get retryPolicy(): IRetryPolicy {\r\n    return {\r\n      nextRetryDelayInMilliseconds: retryContext => {\r\n        if (retryContext.elapsedMilliseconds < 60000) {\r\n          return Math.random() * 10000;\r\n        } else {\r\n          return 30000;\r\n        }\r\n      }\r\n    };\r\n  }\r\n\r\n  async createHubConnection() {\r\n    this.eventSubject = new Subject<SignalrEvent>(); \r\n\r\n    const hubEndPoint = this.environment.signalRUrl;\r\n    this.connection = new HubConnectionBuilder()\r\n      .withUrl(hubEndPoint + '/signalr', this.hubConnectionOptions)\r\n      .withHubProtocol(new MessagePackHubProtocol())\r\n      .withAutomaticReconnect(this.retryPolicy)\r\n      .configureLogging(LogLevel.Information)\r\n      .build();\r\n\r\n    this.connection.start();\r\n\r\n    this.connection.on('onEvent', (event: SignalrEvent) => {\r\n      switch (event.Name) {\r\n        case 'ErrorAtHub':\r\n          console.warn('Error At Hub:', event.Payload);\r\n          break;\r\n        case 'LoggingAtHub':\r\n          console.warn('Logging At Hub:', event.Payload);\r\n          break;\r\n        default:\r\n          this.zone.run(() => this.eventSubject.next(event));\r\n          break;\r\n      }\r\n    });\r\n\r\n    this.connection.onreconnecting(error => this.handleOnReconnecting(error));\r\n    this.connection.onreconnected(connectionId => this.handleOnReconnected(connectionId));\r\n    this.connection.onclose(error => this.handleOnClose(error));\r\n\r\n    this.event$ = this.eventSubject.asObservable();\r\n  }\r\n\r\n  private handleOnReconnecting(error: Error): void {\r\n    console.log('Hub connection started reconnecting due to an error: ', error);\r\n  }\r\n\r\n  private handleOnReconnected(connectionId: string): void {\r\n    console.log('Hub connection successfully reconnected. ConnectionId is now: ', connectionId);\r\n  }\r\n\r\n  private handleOnClose(error: Error): void {\r\n    if(error === null){\r\n      console.log('Hub connection closed without error.', error);\r\n    }\r\n    else{\r\n      console.log('Hub connection closed due to an error: ', error);\r\n    }\r\n  }\r\n\r\n  getEvent(): Observable<PushChangeEvent> {\r\n    return this.event$.pipe(map(event => {\r\n      return <PushChangeEvent>{\r\n        name: event.Name,\r\n        payload: event.Payload\r\n      }\r\n    }));\r\n  }\r\n\r\n  getConnectionId(): string {\r\n    return this.connection.connectionId;\r\n  }\r\n\r\n  joinGroup(groupName: string) {\r\n    this.connection.invoke(\"JoinGroup\", groupName);\r\n  }\r\n\r\n  removeFromGroup(groupName: string) {\r\n    this.connection.invoke(\"RemoveFromGroup\", groupName)\r\n  }\r\n\r\n  sendToClientGroup(groupsToSend: string[], serviceName: string, events: any) {\r\n    this.connection.invoke(\"SendToClientGroup\", groupsToSend, serviceName, events);\r\n  }\r\n\r\n  sendToClientUser(userToSend: string, serviceName: string, events: any) {\r\n    this.connection.invoke(\"SendToClientUser\", userToSend, serviceName, events);\r\n  }\r\n\r\n  sendToAllClients(serviceName: string, events: any) {\r\n    this.connection.invoke(\"SendToAllClients\", serviceName, events);\r\n  }\r\n\r\n  sendToCaller(serviceName: string, events: any) {\r\n    this.connection.invoke(\"SendToCaller\", serviceName, events);\r\n  }\r\n}\r\n\r\nexport const SignalRHeader = {\r\n  SignalRKey: \"3D36C63093B75A091E116182BE91FFB99D53192365C6222979587514E6F65994\"\r\n} as MessageHeaders\r\n"]}

package/esm2020/lib/services/zcomponent.service.mjs

@@ -122,9 +122,9 @@ export class ZComponentService {
             return null;
         }
     }
-    translateToolBarItems(items) {
+    translateToolBarItems(items, group) {
         const obsList = new Array();
-        obsList.push(this.translateService.$translateItemList(items, "text", this.environment.applicationShortName, "general"));
+        obsList.push(this.translateService.$translateItemList(items, "text", { elementName: 'general', group }));
         if (obsList.length <= 0) {
             return of({});
         }
@@ -132,7 +132,7 @@ export class ZComponentService {
     }
     translateGridColumnHeader(columns, group) {
         const obsList = new Array();
-        obsList.push(this.translateService.$translateItemList(columns, "title", this.environment.applicationShortName, group.fieldName));
+        obsList.push(this.translateService.$translateItemList(columns, "title", { elementName: 'menu', group }));
         if (obsList.length <= 0) {
             return of({});
         }
@@ -140,7 +140,7 @@ export class ZComponentService {
     }
     translateButtonComponent(buttons, group) {
         let obsList = new Array();
-        obsList.push(this.translateService.$translateItemList(buttons, "text", this.environment.applicationShortName, group.fieldName));
+        obsList.push(this.translateService.$translateItemList(buttons, "text", { elementName: group.fieldName, group }));
         if (obsList.length <= 0) {
             return of({});
         }
@@ -151,7 +151,7 @@ export class ZComponentService {
         const propList = ["Label", "PlaceHolder", "Title"]; // ToolTip
         for (const prop of propList) {
             if (data[prop] != undefined) {
-                const obs = this.translateCompByProperty(data, prop, group.fieldName);
+                const obs = this.translateCompByProperty(data, prop, group.fieldName, group);
                 if (obs) {
                     obsList = obsList.concat(obs);
                 }
@@ -167,7 +167,7 @@ export class ZComponentService {
         const propList = ["label", "title"];
         for (const prop of propList) {
             if (componentProperties[prop] != undefined) {
-                const obs = this.translateCompByProperty(componentProperties, prop, group.fieldName);
+                const obs = this.translateCompByProperty(componentProperties, prop, group.fieldName, group);
                 if (obs) {
                     obsList = obsList.concat(obs);
                 }
@@ -178,18 +178,20 @@ export class ZComponentService {
         }
         return forkJoin(obsList);
     }
-    translateCompByProperty(data, propName, fieldName) {
+    translateCompByProperty(data, propName, fieldName, group) {
         if (data[propName] == undefined || data[propName] == "") {
             return;
         }
         const obsList = new Array();
         if (Array.isArray(data[propName]) && data[propName].length > 0) {
-            obsList.push(this.translateService.$translateItemList(data[propName], null, this.environment.applicationShortName, fieldName).pipe(tap(resp => {
+            obsList.push(this.translateService.$translateItemList(data[propName], null, { elementName: fieldName, group }).pipe(tap(resp => {
                 data[propName] = resp;
             })));
         }
         else {
-            obsList.push(this.translateService.$translateSingleItem(data, propName, this.environment.applicationShortName, fieldName));
+            obsList.push(this.translateService.$translateSingleItem(data, propName, { elementName: fieldName, group }).pipe(tap(resp => {
+                data[propName] = resp;
+            })));
         }
         return obsList;
     }
@@ -202,4 +204,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.ComponentObjectService }, { type: i2.TranslationService }, { type: i2.ZCoreService }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zcomponent.service.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/services/zcomponent.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, ComponentFactoryResolver, EmbeddedViewRef } from \"@angular/core\";\r\nimport { FormGroup } from '@angular/forms';\r\nimport { ZComponent, ZComponentHelper, ZComponentProperties, ZCoreService, ZField, ZGroup, TranslationService } from 'mmhglobal-zcore';\r\n// import { ComponentObjectService } from 'projects/mmhglobal-middleware/src/public-api';\r\nimport { ComponentObjectService } from 'mmhglobal-middleware';\r\nimport { forkJoin, Observable, of, tap } from \"rxjs\";\r\nimport { FieldElementDirective } from '../directives/fieldelement.directive';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ZComponentService {\r\n\r\n  public environment;\r\n  constructor(\r\n    private componentObjectService: ComponentObjectService,\r\n    private translateService: TranslationService,\r\n    private zcoreService: ZCoreService,\r\n  ) {\r\n    this.environment = this.zcoreService.getEnvironment();\r\n  }\r\n\r\n  public isSkipComponentType(componentType: string): boolean {\r\n    return ZComponentHelper.isSkipComponentType(componentType);\r\n  }\r\n\r\n  public loadComponent(\r\n    componentFactoryResolver: ComponentFactoryResolver,\r\n    fieldElement: FieldElementDirective,\r\n    field: any,\r\n    group: any,\r\n    form: FormGroup,\r\n    containerField: any\r\n  ) {\r\n    // if(field.Name === 'FormDetailContactGrid') {\r\n    //   debugger;\r\n    // }\r\n\r\n    if (this.isSkipComponentType(field.Type)) {\r\n      return;\r\n    }\r\n\r\n    let componentFactory;\r\n    const componentName = this.componentObjectService.getObject(field.Type);\r\n    if (componentName) {\r\n      componentFactory = componentFactoryResolver.resolveComponentFactory(\r\n        componentName\r\n      );\r\n    } else {\r\n      componentFactory = componentFactoryResolver.resolveComponentFactory(\r\n        this.componentObjectService.getObject(\"unknown\")\r\n      );\r\n    }\r\n\r\n    const viewContainerRef = fieldElement.viewContainerRef;\r\n    viewContainerRef.clear();\r\n    if (!form) {\r\n      console.warn('FormGroup is empty!');\r\n      debugger;\r\n    }\r\n    const componentRef = viewContainerRef.createComponent(componentFactory);\r\n    (componentRef.instance as ZComponent).data = field;\r\n    (componentRef.instance as ZComponent).group = group;\r\n    (componentRef.instance as ZComponent).form = form;\r\n    (componentRef.instance as ZComponent).containerField = containerField;\r\n    // (componentRef.instance as ZComponent).outputEvent.subscribe((event: any) => group.outputEvent(event));\r\n  }\r\n\r\n  appendComponentToDynamicForm(\r\n    componentFactoryResolver: ComponentFactoryResolver,\r\n    injector: any,\r\n    appRef: any,\r\n    field: any,\r\n    group: any,\r\n    containerId: string\r\n  ) {\r\n    if (this.isSkipComponentType(field.Type)) {\r\n      return;\r\n    }\r\n\r\n    let componentRef;\r\n    const componentName = this.componentObjectService.getObject(field.Type);\r\n    // 1. Create a component reference from the component\r\n    if (componentName) {\r\n      componentRef = componentFactoryResolver\r\n        .resolveComponentFactory(componentName)\r\n        .create(injector);\r\n    } else {\r\n      componentRef = componentFactoryResolver\r\n        .resolveComponentFactory(this.componentObjectService.getObject(\"unknown\"))\r\n        .create(injector);\r\n    }\r\n\r\n    // 2. Attach component to the appRef so that it's inside the ng component tree\r\n    appRef.attachView(componentRef.hostView);\r\n\r\n    // 3. Get DOM element from component\r\n    const domElem = (componentRef.hostView as EmbeddedViewRef<any>)\r\n      .rootNodes[0] as HTMLElement;\r\n\r\n    // 4. Append DOM element to the body\r\n    const dynamicFormHost: any = document.querySelector(\"#\" + containerId);\r\n    dynamicFormHost.appendChild(domElem);\r\n\r\n    (componentRef.instance as ZComponent).data = field;\r\n    (componentRef.instance as ZComponent).group = group;\r\n    return componentRef;\r\n  }\r\n\r\n  private readonly DEFAULT_ISEDIT = true;\r\n  public setEditMode(me: any) {\r\n    let editmode;\r\n    if (me && me.data && me.data.EditMode != undefined) {\r\n      if (typeof me.data.EditMode != \"object\") {\r\n        let editMode = ZComponentHelper.getGroupValue(me.data.EditMode, me.group);\r\n        editmode = { value: editMode, initValue: editMode };\r\n      }\r\n      else {\r\n        editmode = me.data.EditMode;\r\n      }\r\n    }\r\n    me.data.EditMode = editmode || ((me.containerField && me.containerField.EditMode) ? me.containerField.EditMode : { value: this.DEFAULT_ISEDIT, initValue: this.DEFAULT_ISEDIT });\r\n    me.data.EditMode.value = me.data.EditMode.initValue;\r\n    // const editmode = (me && me.data && me.data.EditMode != undefined) ? (typeof me.data.EditMode == \"boolean\" ? { value: me.data.EditMode, initValue: me.data.EditMode } : me.data.EditMode) : null;\r\n  }\r\n\r\n  public setComponentAdditionalProperties(me: any) {\r\n    me.componentProperties.title = me.data && me.data.Title && me.data.Title.includes(\"group.\") ? ZComponentHelper.getGroupEvalValue.call(me, me.data.Title) : me.data.Title;\r\n    me.componentProperties.icon = me.data && me.data.Icon && me.data.Icon.includes(\"group.\") ? ZComponentHelper.getGroupEvalValue.call(me, me.data.Icon) : me.data.Icon;\r\n    me.componentProperties.label = me.data && me.data.Label && me.data.Label.includes(\"group.\") ? ZComponentHelper.getGroupEvalValue.call(me, me.data.Label) : me.data.Label;\r\n  }\r\n\r\n  public setCompStylesByIndex(me: any) {\r\n    for (const key of Object.keys(me.componentProperties.style)) {\r\n      const ind = key.replace('style', '');\r\n      this.setStyleByIndex(me, ind, ZComponentHelper.getGroupValue(me.data[`Style${ind}`], me.group) || \"\");\r\n    }\r\n\r\n    for (const key of Object.keys(me.componentProperties.containerStyle)) {\r\n      const ind = key.replace('style', '');\r\n      this.setContainerStyleByIndex(me, ind, ZComponentHelper.getGroupValue(me.data[`ContainerStyle${ind}`], me.group) || \"\");\r\n    }\r\n  }\r\n\r\n  public setStyleByIndex(me: any, ind: string, style: string) {\r\n    me.componentProperties.style[`style${ind}`] = style;\r\n  }\r\n\r\n  public setContainerStyleByIndex(me: any, ind: string, style: string) {\r\n    me.componentProperties.containerStyle[`style${ind}`] = style;\r\n  }\r\n\r\n  public convertStyleStringToObject(styleString: string): any {\r\n    try {\r\n      const styleArr = styleString.split(\";\").filter(x => x);\r\n      const styleObj = {};\r\n      for (const style of styleArr) {\r\n        const kvp = style.split(\":\");\r\n        styleObj[kvp[0].trim()] = kvp[1].trim();\r\n      }\r\n\r\n      return styleObj;\r\n    }\r\n    catch (err) {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  public translateToolBarItems(items: Array<any>): Observable<any> {\r\n    const obsList = new Array<Observable<any>>();\r\n    obsList.push(this.translateService.$translateItemList(items, \"text\", this.environment.applicationShortName, \"general\"));\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n  public translateGridColumnHeader(columns: Array<any>, group: ZGroup): Observable<any> {\r\n    const obsList = new Array<Observable<any>>();\r\n    obsList.push(this.translateService.$translateItemList(columns, \"title\", this.environment.applicationShortName, group.fieldName));\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n  public translateButtonComponent(buttons: Array<any>, group: ZGroup): Observable<any> {\r\n    let obsList = new Array<Observable<any>>();\r\n    obsList.push(this.translateService.$translateItemList(buttons, \"text\", this.environment.applicationShortName, group.fieldName));\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n  public translateComponentField(data: ZField, group: ZGroup): Observable<any> {\r\n    let obsList = new Array<Observable<any>>();\r\n\r\n    const propList = [\"Label\", \"PlaceHolder\", \"Title\"]; // ToolTip\r\n    for (const prop of propList) {\r\n      if (data[prop] != undefined) {\r\n        const obs = this.translateCompByProperty(data, prop, group.fieldName);\r\n        if (obs) {\r\n          obsList = obsList.concat(obs);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n  public translateComponentProperties(componentProperties: ZComponentProperties, group: ZGroup): Observable<any> {\r\n    let obsList = new Array<Observable<any>>();\r\n\r\n    const propList = [\"label\", \"title\"];\r\n    for (const prop of propList) {\r\n      if (componentProperties[prop] != undefined) {\r\n        const obs = this.translateCompByProperty(componentProperties, prop, group.fieldName);\r\n        if (obs) {\r\n          obsList = obsList.concat(obs);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n\r\n  private translateCompByProperty(data: any, propName: string, fieldName: string): Array<Observable<any>> {\r\n    if (data[propName] == undefined || data[propName] == \"\") {\r\n      return;\r\n    }\r\n\r\n    const obsList = new Array<Observable<any>>();\r\n    if (Array.isArray(data[propName]) && data[propName].length > 0) {\r\n      obsList.push(this.translateService.$translateItemList(data[propName], null, this.environment.applicationShortName, fieldName).pipe(\r\n        tap(resp => {\r\n          data[propName] = resp;\r\n        }))\r\n      );\r\n    }\r\n    else {\r\n      obsList.push(this.translateService.$translateSingleItem(data, propName, this.environment.applicationShortName, fieldName));\r\n    }\r\n\r\n    return obsList;\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zcomponent.service.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/services/zcomponent.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA6C,MAAM,eAAe,CAAC;AAEtF,OAAO,EAAc,gBAAgB,EAA0E,MAAM,iBAAiB,CAAC;AAGvI,OAAO,EAAE,QAAQ,EAAc,EAAE,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;;;;AAMrD,MAAM,OAAO,iBAAiB;IAG5B,YACU,sBAA8C,EAC9C,gBAAoC,EACpC,YAA0B;QAF1B,2BAAsB,GAAtB,sBAAsB,CAAwB;QAC9C,qBAAgB,GAAhB,gBAAgB,CAAoB;QACpC,iBAAY,GAAZ,YAAY,CAAc;QA4FnB,mBAAc,GAAG,IAAI,CAAC;QA1FrC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;IACxD,CAAC;IAEM,mBAAmB,CAAC,aAAqB;QAC9C,OAAO,gBAAgB,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;IAC7D,CAAC;IAEM,aAAa,CAClB,wBAAkD,EAClD,YAAmC,EACnC,KAAU,EACV,KAAU,EACV,IAAe,EACf,cAAmB;QAEnB,+CAA+C;QAC/C,cAAc;QACd,IAAI;QAEJ,IAAI,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;YACxC,OAAO;SACR;QAED,IAAI,gBAAgB,CAAC;QACrB,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACxE,IAAI,aAAa,EAAE;YACjB,gBAAgB,GAAG,wBAAwB,CAAC,uBAAuB,CACjE,aAAa,CACd,CAAC;SACH;aAAM;YACL,gBAAgB,GAAG,wBAAwB,CAAC,uBAAuB,CACjE,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,SAAS,CAAC,CACjD,CAAC;SACH;QAED,MAAM,gBAAgB,GAAG,YAAY,CAAC,gBAAgB,CAAC;QACvD,gBAAgB,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,IAAI,EAAE;YACT,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACpC,QAAQ,CAAC;SACV;QACD,MAAM,YAAY,GAAG,gBAAgB,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC;QACvE,YAAY,CAAC,QAAuB,CAAC,IAAI,GAAG,KAAK,CAAC;QAClD,YAAY,CAAC,QAAuB,CAAC,KAAK,GAAG,KAAK,CAAC;QACnD,YAAY,CAAC,QAAuB,CAAC,IAAI,GAAG,IAAI,CAAC;QACjD,YAAY,CAAC,QAAuB,CAAC,cAAc,GAAG,cAAc,CAAC;QACtE,yGAAyG;IAC3G,CAAC;IAED,4BAA4B,CAC1B,wBAAkD,EAClD,QAAa,EACb,MAAW,EACX,KAAU,EACV,KAAU,EACV,WAAmB;QAEnB,IAAI,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;YACxC,OAAO;SACR;QAED,IAAI,YAAY,CAAC;QACjB,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACxE,qDAAqD;QACrD,IAAI,aAAa,EAAE;YACjB,YAAY,GAAG,wBAAwB;iBACpC,uBAAuB,CAAC,aAAa,CAAC;iBACtC,MAAM,CAAC,QAAQ,CAAC,CAAC;SACrB;aAAM;YACL,YAAY,GAAG,wBAAwB;iBACpC,uBAAuB,CAAC,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;iBACzE,MAAM,CAAC,QAAQ,CAAC,CAAC;SACrB;QAED,8EAA8E;QAC9E,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAEzC,oCAAoC;QACpC,MAAM,OAAO,GAAI,YAAY,CAAC,QAAiC;aAC5D,SAAS,CAAC,CAAC,CAAgB,CAAC;QAE/B,oCAAoC;QACpC,MAAM,eAAe,GAAQ,QAAQ,CAAC,aAAa,CAAC,GAAG,GAAG,WAAW,CAAC,CAAC;QACvE,eAAe,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAEpC,YAAY,CAAC,QAAuB,CAAC,IAAI,GAAG,KAAK,CAAC;QAClD,YAAY,CAAC,QAAuB,CAAC,KAAK,GAAG,KAAK,CAAC;QACpD,OAAO,YAAY,CAAC;IACtB,CAAC;IAGM,WAAW,CAAC,EAAO;QACxB,IAAI,QAAQ,CAAC;QACb,IAAI,EAAE,IAAI,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,SAAS,EAAE;YAClD,IAAI,OAAO,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,QAAQ,EAAE;gBACvC,IAAI,QAAQ,GAAG,gBAAgB,CAAC,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;gBAC1E,QAAQ,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC;aACrD;iBACI;gBACH,QAAQ,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC;aAC7B;SACF;QACD,EAAE,CAAC,IAAI,CAAC,QAAQ,GAAG,QAAQ,IAAI,CAAC,CAAC,EAAE,CAAC,cAAc,IAAI,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,SAAS,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QACjL,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;QACpD,mMAAmM;IACrM,CAAC;IAEM,gCAAgC,CAAC,EAAO;QAC7C,EAAE,CAAC,mBAAmB,CAAC,KAAK,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC;QACzK,EAAE,CAAC,mBAAmB,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;QACpK,EAAE,CAAC,mBAAmB,CAAC,KAAK,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC;IAC3K,CAAC;IAEM,oBAAoB,CAAC,EAAO;QACjC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE;YAC3D,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YACrC,IAAI,CAAC,eAAe,CAAC,EAAE,EAAE,GAAG,EAAE,gBAAgB,CAAC,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;SACvG;QAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,cAAc,CAAC,EAAE;YACpE,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YACrC,IAAI,CAAC,wBAAwB,CAAC,EAAE,EAAE,GAAG,EAAE,gBAAgB,CAAC,aAAa,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;SACzH;IACH,CAAC;IAEM,eAAe,CAAC,EAAO,EAAE,GAAW,EAAE,KAAa;QACxD,EAAE,CAAC,mBAAmB,CAAC,KAAK,CAAC,QAAQ,GAAG,EAAE,CAAC,GAAG,KAAK,CAAC;IACtD,CAAC;IAEM,wBAAwB,CAAC,EAAO,EAAE,GAAW,EAAE,KAAa;QACjE,EAAE,CAAC,mBAAmB,CAAC,cAAc,CAAC,QAAQ,GAAG,EAAE,CAAC,GAAG,KAAK,CAAC;IAC/D,CAAC;IAEM,0BAA0B,CAAC,WAAmB;QACnD,IAAI;YACF,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACvD,MAAM,QAAQ,GAAG,EAAE,CAAC;YACpB,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE;gBAC5B,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC7B,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;aACzC;YAED,OAAO,QAAQ,CAAC;SACjB;QACD,OAAO,GAAG,EAAE;YACV,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAEM,qBAAqB,CAAC,KAAiB,EAAE,KAAa;QAC3D,MAAM,OAAO,GAAG,IAAI,KAAK,EAAmB,CAAC;QAC7C,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QAEzG,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE;YACvB,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;SACf;QACD,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAEM,yBAAyB,CAAC,OAAmB,EAAE,KAAa;QACjE,MAAM,OAAO,GAAG,IAAI,KAAK,EAAmB,CAAC;QAC7C,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QAEzG,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE;YACvB,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;SACf;QACD,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAEM,wBAAwB,CAAC,OAAmB,EAAE,KAAa;QAChE,IAAI,OAAO,GAAG,IAAI,KAAK,EAAmB,CAAC;QAC3C,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QAEjH,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE;YACvB,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;SACf;QACD,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAEM,uBAAuB,CAAC,IAAY,EAAE,KAAa;QACxD,IAAI,OAAO,GAAG,IAAI,KAAK,EAAmB,CAAC;QAE3C,MAAM,QAAQ,GAAG,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC,UAAU;QAC9D,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE;YAC3B,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,SAAS,EAAE;gBAC3B,MAAM,GAAG,GAAG,IAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;gBAC7E,IAAI,GAAG,EAAE;oBACP,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;iBAC/B;aACF;SACF;QAED,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE;YACvB,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;SACf;QACD,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAEM,4BAA4B,CAAC,mBAAyC,EAAE,KAAa;QAC1F,IAAI,OAAO,GAAG,IAAI,KAAK,EAAmB,CAAC;QAE3C,MAAM,QAAQ,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACpC,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE;YAC3B,IAAI,mBAAmB,CAAC,IAAI,CAAC,IAAI,SAAS,EAAE;gBAC1C,MAAM,GAAG,GAAG,IAAI,CAAC,uBAAuB,CAAC,mBAAmB,EAAE,IAAI,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;gBAC5F,IAAI,GAAG,EAAE;oBACP,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;iBAC/B;aACF;SACF;QAED,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,EAAE;YACvB,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;SACf;QACD,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAGO,uBAAuB,CAAC,IAAS,EAAE,QAAgB,EAAE,SAAiB,EAAE,KAAa;QAC3F,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,SAAS,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE;YACvD,OAAO;SACR;QAED,MAAM,OAAO,GAAG,IAAI,KAAK,EAAmB,CAAC;QAC7C,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;YAC9D,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,IAAI,CACjH,GAAG,CAAC,IAAI,CAAC,EAAE;gBACT,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;YACxB,CAAC,CAAC,CAAC,CACJ,CAAC;SACH;aACI;YACH,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,IAAI,CAC7G,GAAG,CAAC,IAAI,CAAC,EAAE;gBACT,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;YACxB,CAAC,CAAC,CAAC,CACJ,CAAA;SACF;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;;+GAxPU,iBAAiB;mHAAjB,iBAAiB,cAFhB,MAAM;4FAEP,iBAAiB;kBAH7B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable, ComponentFactoryResolver, EmbeddedViewRef } from \"@angular/core\";\r\nimport { FormGroup } from '@angular/forms';\r\nimport { ZComponent, ZComponentHelper, ZComponentProperties, ZCoreService, ZField, ZGroup, TranslationService } from 'mmhglobal-zcore';\r\n// import { ComponentObjectService } from 'projects/mmhglobal-middleware/src/public-api';\r\nimport { ComponentObjectService } from 'mmhglobal-middleware';\r\nimport { forkJoin, Observable, of, tap } from \"rxjs\";\r\nimport { FieldElementDirective } from '../directives/fieldelement.directive';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ZComponentService {\r\n\r\n  public environment;\r\n  constructor(\r\n    private componentObjectService: ComponentObjectService,\r\n    private translateService: TranslationService,\r\n    private zcoreService: ZCoreService,\r\n  ) {\r\n    this.environment = this.zcoreService.getEnvironment();\r\n  }\r\n\r\n  public isSkipComponentType(componentType: string): boolean {\r\n    return ZComponentHelper.isSkipComponentType(componentType);\r\n  }\r\n\r\n  public loadComponent(\r\n    componentFactoryResolver: ComponentFactoryResolver,\r\n    fieldElement: FieldElementDirective,\r\n    field: any,\r\n    group: any,\r\n    form: FormGroup,\r\n    containerField: any\r\n  ) {\r\n    // if(field.Name === 'FormDetailContactGrid') {\r\n    //   debugger;\r\n    // }\r\n\r\n    if (this.isSkipComponentType(field.Type)) {\r\n      return;\r\n    }\r\n\r\n    let componentFactory;\r\n    const componentName = this.componentObjectService.getObject(field.Type);\r\n    if (componentName) {\r\n      componentFactory = componentFactoryResolver.resolveComponentFactory(\r\n        componentName\r\n      );\r\n    } else {\r\n      componentFactory = componentFactoryResolver.resolveComponentFactory(\r\n        this.componentObjectService.getObject(\"unknown\")\r\n      );\r\n    }\r\n\r\n    const viewContainerRef = fieldElement.viewContainerRef;\r\n    viewContainerRef.clear();\r\n    if (!form) {\r\n      console.warn('FormGroup is empty!');\r\n      debugger;\r\n    }\r\n    const componentRef = viewContainerRef.createComponent(componentFactory);\r\n    (componentRef.instance as ZComponent).data = field;\r\n    (componentRef.instance as ZComponent).group = group;\r\n    (componentRef.instance as ZComponent).form = form;\r\n    (componentRef.instance as ZComponent).containerField = containerField;\r\n    // (componentRef.instance as ZComponent).outputEvent.subscribe((event: any) => group.outputEvent(event));\r\n  }\r\n\r\n  appendComponentToDynamicForm(\r\n    componentFactoryResolver: ComponentFactoryResolver,\r\n    injector: any,\r\n    appRef: any,\r\n    field: any,\r\n    group: any,\r\n    containerId: string\r\n  ) {\r\n    if (this.isSkipComponentType(field.Type)) {\r\n      return;\r\n    }\r\n\r\n    let componentRef;\r\n    const componentName = this.componentObjectService.getObject(field.Type);\r\n    // 1. Create a component reference from the component\r\n    if (componentName) {\r\n      componentRef = componentFactoryResolver\r\n        .resolveComponentFactory(componentName)\r\n        .create(injector);\r\n    } else {\r\n      componentRef = componentFactoryResolver\r\n        .resolveComponentFactory(this.componentObjectService.getObject(\"unknown\"))\r\n        .create(injector);\r\n    }\r\n\r\n    // 2. Attach component to the appRef so that it's inside the ng component tree\r\n    appRef.attachView(componentRef.hostView);\r\n\r\n    // 3. Get DOM element from component\r\n    const domElem = (componentRef.hostView as EmbeddedViewRef<any>)\r\n      .rootNodes[0] as HTMLElement;\r\n\r\n    // 4. Append DOM element to the body\r\n    const dynamicFormHost: any = document.querySelector(\"#\" + containerId);\r\n    dynamicFormHost.appendChild(domElem);\r\n\r\n    (componentRef.instance as ZComponent).data = field;\r\n    (componentRef.instance as ZComponent).group = group;\r\n    return componentRef;\r\n  }\r\n\r\n  private readonly DEFAULT_ISEDIT = true;\r\n  public setEditMode(me: any) {\r\n    let editmode;\r\n    if (me && me.data && me.data.EditMode != undefined) {\r\n      if (typeof me.data.EditMode != \"object\") {\r\n        let editMode = ZComponentHelper.getGroupValue(me.data.EditMode, me.group);\r\n        editmode = { value: editMode, initValue: editMode };\r\n      }\r\n      else {\r\n        editmode = me.data.EditMode;\r\n      }\r\n    }\r\n    me.data.EditMode = editmode || ((me.containerField && me.containerField.EditMode) ? me.containerField.EditMode : { value: this.DEFAULT_ISEDIT, initValue: this.DEFAULT_ISEDIT });\r\n    me.data.EditMode.value = me.data.EditMode.initValue;\r\n    // const editmode = (me && me.data && me.data.EditMode != undefined) ? (typeof me.data.EditMode == \"boolean\" ? { value: me.data.EditMode, initValue: me.data.EditMode } : me.data.EditMode) : null;\r\n  }\r\n\r\n  public setComponentAdditionalProperties(me: any) {\r\n    me.componentProperties.title = me.data && me.data.Title && me.data.Title.includes(\"group.\") ? ZComponentHelper.getGroupEvalValue.call(me, me.data.Title) : me.data.Title;\r\n    me.componentProperties.icon = me.data && me.data.Icon && me.data.Icon.includes(\"group.\") ? ZComponentHelper.getGroupEvalValue.call(me, me.data.Icon) : me.data.Icon;\r\n    me.componentProperties.label = me.data && me.data.Label && me.data.Label.includes(\"group.\") ? ZComponentHelper.getGroupEvalValue.call(me, me.data.Label) : me.data.Label;\r\n  }\r\n\r\n  public setCompStylesByIndex(me: any) {\r\n    for (const key of Object.keys(me.componentProperties.style)) {\r\n      const ind = key.replace('style', '');\r\n      this.setStyleByIndex(me, ind, ZComponentHelper.getGroupValue(me.data[`Style${ind}`], me.group) || \"\");\r\n    }\r\n\r\n    for (const key of Object.keys(me.componentProperties.containerStyle)) {\r\n      const ind = key.replace('style', '');\r\n      this.setContainerStyleByIndex(me, ind, ZComponentHelper.getGroupValue(me.data[`ContainerStyle${ind}`], me.group) || \"\");\r\n    }\r\n  }\r\n\r\n  public setStyleByIndex(me: any, ind: string, style: string) {\r\n    me.componentProperties.style[`style${ind}`] = style;\r\n  }\r\n\r\n  public setContainerStyleByIndex(me: any, ind: string, style: string) {\r\n    me.componentProperties.containerStyle[`style${ind}`] = style;\r\n  }\r\n\r\n  public convertStyleStringToObject(styleString: string): any {\r\n    try {\r\n      const styleArr = styleString.split(\";\").filter(x => x);\r\n      const styleObj = {};\r\n      for (const style of styleArr) {\r\n        const kvp = style.split(\":\");\r\n        styleObj[kvp[0].trim()] = kvp[1].trim();\r\n      }\r\n\r\n      return styleObj;\r\n    }\r\n    catch (err) {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  public translateToolBarItems(items: Array<any>, group: ZGroup): Observable<any> {\r\n    const obsList = new Array<Observable<any>>();\r\n    obsList.push(this.translateService.$translateItemList(items, \"text\", { elementName: 'general', group }));\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n  public translateGridColumnHeader(columns: Array<any>, group: ZGroup): Observable<any> {\r\n    const obsList = new Array<Observable<any>>();\r\n    obsList.push(this.translateService.$translateItemList(columns, \"title\", { elementName: 'menu', group }));\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n  public translateButtonComponent(buttons: Array<any>, group: ZGroup): Observable<any> {\r\n    let obsList = new Array<Observable<any>>();\r\n    obsList.push(this.translateService.$translateItemList(buttons, \"text\", { elementName: group.fieldName, group }));\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n  public translateComponentField(data: ZField, group: ZGroup): Observable<any> {\r\n    let obsList = new Array<Observable<any>>();\r\n\r\n    const propList = [\"Label\", \"PlaceHolder\", \"Title\"]; // ToolTip\r\n    for (const prop of propList) {\r\n      if (data[prop] != undefined) {\r\n        const obs = this.translateCompByProperty(data, prop, group.fieldName, group);\r\n        if (obs) {\r\n          obsList = obsList.concat(obs);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n  public translateComponentProperties(componentProperties: ZComponentProperties, group: ZGroup): Observable<any> {\r\n    let obsList = new Array<Observable<any>>();\r\n\r\n    const propList = [\"label\", \"title\"];\r\n    for (const prop of propList) {\r\n      if (componentProperties[prop] != undefined) {\r\n        const obs = this.translateCompByProperty(componentProperties, prop, group.fieldName, group);\r\n        if (obs) {\r\n          obsList = obsList.concat(obs);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (obsList.length <= 0) {\r\n      return of({});\r\n    }\r\n    return forkJoin(obsList);\r\n  }\r\n\r\n\r\n  private translateCompByProperty(data: any, propName: string, fieldName: string, group: ZGroup): Array<Observable<any>> {\r\n    if (data[propName] == undefined || data[propName] == \"\") {\r\n      return;\r\n    }\r\n\r\n    const obsList = new Array<Observable<any>>();\r\n    if (Array.isArray(data[propName]) && data[propName].length > 0) {\r\n      obsList.push(this.translateService.$translateItemList(data[propName], null, { elementName: fieldName, group }).pipe(\r\n        tap(resp => {\r\n          data[propName] = resp;\r\n        }))\r\n      );\r\n    }\r\n    else {\r\n      obsList.push(this.translateService.$translateSingleItem(data, propName, { elementName: fieldName, group }).pipe(\r\n        tap(resp => {\r\n          data[propName] = resp;\r\n        }))\r\n      )\r\n    }\r\n\r\n    return obsList;\r\n  }\r\n}\r\n\r\n"]}

package/esm2020/lib/uiappmenucontent/uiappmenucontent.component.mjs

@@ -36,7 +36,14 @@ export class UiappmenucontentComponent {
             return false;
         }
         else {
-            this.mainService.setNavigationParams([pathName, pathName]);
+            if (startupPage.indexOf('_', 0) == 0) {
+                // menu page
+                this.mainService.setNavigationParams([startupPage]);
+            }
+            else {
+                // home page
+                this.mainService.setNavigationParams([pathName]);
+            }
             this.router.navigate([pathName]);
         }
     }
@@ -49,11 +56,11 @@ export class UiappmenucontentComponent {
     }
 }
 UiappmenucontentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UiappmenucontentComponent, deps: [{ token: i1.Router }, { token: i2.MenuService }, { token: i2.AuthService }, { token: i2.ZCoreService }, { token: i3.MainService }], target: i0.ɵɵFactoryTarget.Component });
-UiappmenucontentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: UiappmenucontentComponent, selector: "app-uiappmenucontent", inputs: { items: "items" }, ngImport: i0, template: "<ion-grid>\r\n  <ion-row>\r\n    <ion-col [ngClass]=\"getDivClass(item)\" *ngFor=\"let item of items; index as i\">\r\n      <div *ngIf=\"item.Type !== 'dropdown-submenu'\" class=\"menu-btn ion-activatable ripple-parent\"\r\n        (click)=\"menuOnClick(item.URL, item.AppClientPath)\">\r\n        <ion-label class=\"menu-btn-label menu-btn-icon\">\r\n          <fa-icon class=\"menu-icon\" [icon]=\"['fas', item.Icon ]\" [inverse]=\"true\"></fa-icon>\r\n          <ion-badge color=\"danger\" class=\"pending-counter\"\r\n            *ngIf=\"item['PendingCounter'] && item['PendingCounter'] > 0\">\r\n            {{item['PendingCounter']}}\r\n          </ion-badge>\r\n        </ion-label>\r\n        <ion-label class=\"menu-btn-label-text\">{{ item.Label }}</ion-label>\r\n        <ion-label *ngIf=\"item.Description\" class=\"menu-btn-label-text menu-btn-label-text-desc\">{{ item.Description }}\r\n        </ion-label>\r\n        <ion-ripple-effect></ion-ripple-effect>\r\n      </div>\r\n\r\n      <kendo-card *ngIf=\"item.Type === 'dropdown-submenu'\">\r\n        <kendo-card-header class=\"k-hstack\">\r\n          <ion-label class=\"card-title\" kendoCardTitle>{{item.Label}}</ion-label>\r\n        </kendo-card-header>\r\n        <kendo-card-body>\r\n          <div class=\"k-hstack\">\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </div>\r\n        </kendo-card-body>\r\n      </kendo-card>\r\n\r\n      <!-- <kendo-panelbar class=\"menu-panel\" *ngIf=\"item.Type === 'dropdown-submenu'\" keepItemContent=\"true\">\r\n        <kendo-panelbar-item [expanded]=\"true\">\r\n          <ng-template kendoPanelBarItemTitle>\r\n            <span *ngIf=\"item.Icon\">\r\n              <fa-icon [icon]=\"item.Icon\" class=\"zcard-header-icon\"></fa-icon>\r\n            </span>\r\n            <span *ngIf=\"!item.Icon\">\r\n              <i class=\"fas fa-folder\" style=\"color: #000000\"></i>\r\n            </span>\r\n            <ion-label class=\"zcard-header-title\">{{item.Label}}</ion-label>\r\n          </ng-template>\r\n          <ng-template kendoPanelBarContent class=\"menu-content-temp\">\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </ng-template>\r\n        </kendo-panelbar-item>\r\n      </kendo-panelbar> -->\r\n    </ion-col>\r\n  </ion-row>\r\n</ion-grid>\r\n", styles: ["ion-grid{max-width:2000px;margin-top:10px}:host ::ng-deep kendo-card{width:95%!important;margin:auto auto 10px;border-radius:var(--ion-container-border-radius);border-left:5px solid var(--ion-color-primary)}:host ::ng-deep kendo-card .k-card-body{padding-top:0}.menu-col{padding:10px}.menu-btn{margin:0;padding:0;border:0px;display:flex;flex-flow:column;justify-content:center;align-items:stretch;background-color:#fff;cursor:pointer;border-radius:5px;box-shadow:1px 1px 4px #797979;min-width:180px;max-width:250px;min-height:120px;max-height:120px;color:#fff;background:var(--ion-color-primary)}.menu-btn:hover{box-shadow:0 0 2px 2px var(--ion-color-secondary)}.menu-btn:hover .menu-btn-label-text-desc{bottom:0px;transition:.5s ease bottom;width:100%}.menu-btn-label-text{text-align:center;font-size:16px;font-weight:600;padding:10px 5px}.menu-btn-label-text-desc{bottom:-100%;transition:.5s ease bottom;display:block;position:absolute;color:#000;font-size:16px;background-color:#fff;padding:8px 10px;border:1px solid #797979;border-radius:5px;text-shadow:0px 0px black;width:100%;text-align:left;font-size:14px;font-weight:500}.ripple-parent{position:relative;overflow:hidden}.menu-btn-label{text-align:center;font-size:15px}.menu-icon{zoom:3;position:relative;top:2px}.menu-btn-icon{background-size:100%}.pending-counter{background-color:#ff243a;border-radius:1em;box-sizing:border-box;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;text-overflow:ellipsis;top:12px;display:inline-block;position:absolute;text-align:center;font-size:1.4em;right:32%}\n"], components: [{ type: i4.IonGrid, selector: "ion-grid", inputs: ["fixed"] }, { type: i4.IonRow, selector: "ion-row" }, { type: i4.IonCol, selector: "ion-col", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }, { type: i4.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { type: i5.FaIconComponent, selector: "fa-icon", inputs: ["icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "classes", "transform", "a11yRole"] }, { type: i4.IonBadge, selector: "ion-badge", inputs: ["color", "mode"] }, { type: i4.IonRippleEffect, selector: "ion-ripple-effect", inputs: ["type"] }, { type: i6.CardComponent, selector: "kendo-card", inputs: ["orientation", "width"] }, { type: i6.CardHeaderComponent, selector: "kendo-card-header" }, { type: i6.CardBodyComponent, selector: "kendo-card-body" }, { type: UiappmenucontentComponent, selector: "app-uiappmenucontent", inputs: ["items"] }], directives: [{ type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i7.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i8.DefaultClassDirective, selector: "  [ngClass], [ngClass.xs], [ngClass.sm], [ngClass.md], [ngClass.lg], [ngClass.xl],  [ngClass.lt-sm], [ngClass.lt-md], [ngClass.lt-lg], [ngClass.lt-xl],  [ngClass.gt-xs], [ngClass.gt-sm], [ngClass.gt-md], [ngClass.gt-lg]", inputs: ["ngClass", "ngClass.xs", "ngClass.sm", "ngClass.md", "ngClass.lg", "ngClass.xl", "ngClass.lt-sm", "ngClass.lt-md", "ngClass.lt-lg", "ngClass.lt-xl", "ngClass.gt-xs", "ngClass.gt-sm", "ngClass.gt-md", "ngClass.gt-lg"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.CardTitleDirective, selector: "[kendoCardTitle]" }] });
+UiappmenucontentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: UiappmenucontentComponent, selector: "app-uiappmenucontent", inputs: { items: "items" }, ngImport: i0, template: "<ion-grid>\r\n  <ion-row>\r\n    <ion-col [ngClass]=\"getDivClass(item)\" *ngFor=\"let item of items; index as i\">\r\n      <div *ngIf=\"item.Type !== 'dropdown-submenu'\" class=\"menu-btn ion-activatable ripple-parent\"\r\n        (click)=\"menuOnClick(item.URL, item.AppClientPath)\">\r\n        <ion-label class=\"menu-btn-label menu-btn-icon\">\r\n          <fa-icon class=\"menu-icon\" [icon]=\"['fas', item.Icon ]\" [inverse]=\"true\"></fa-icon>\r\n          <ion-badge color=\"danger\" class=\"pending-counter\"\r\n            *ngIf=\"item['PendingCounter'] && item['PendingCounter'] > 0\">\r\n            {{item['PendingCounter']}}\r\n          </ion-badge>\r\n        </ion-label>\r\n        <ion-label class=\"menu-btn-label-text\">{{ item.Label }}</ion-label>\r\n        <ion-label *ngIf=\"item.Description\" class=\"menu-btn-label-text menu-btn-label-text-desc\">{{ item.Description }}\r\n        </ion-label>\r\n        <ion-ripple-effect></ion-ripple-effect>\r\n      </div>\r\n\r\n      <kendo-card *ngIf=\"item.Type === 'dropdown-submenu'\">\r\n        <kendo-card-header class=\"k-hstack\">\r\n          <ion-label class=\"card-title\" kendoCardTitle>{{item.Label}}</ion-label>\r\n        </kendo-card-header>\r\n        <kendo-card-body>\r\n          <div>\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </div>\r\n        </kendo-card-body>\r\n      </kendo-card>\r\n\r\n      <!-- <kendo-panelbar class=\"menu-panel\" *ngIf=\"item.Type === 'dropdown-submenu'\" keepItemContent=\"true\">\r\n        <kendo-panelbar-item [expanded]=\"true\">\r\n          <ng-template kendoPanelBarItemTitle>\r\n            <span *ngIf=\"item.Icon\">\r\n              <fa-icon [icon]=\"item.Icon\" class=\"zcard-header-icon\"></fa-icon>\r\n            </span>\r\n            <span *ngIf=\"!item.Icon\">\r\n              <i class=\"fas fa-folder\" style=\"color: #000000\"></i>\r\n            </span>\r\n            <ion-label class=\"zcard-header-title\">{{item.Label}}</ion-label>\r\n          </ng-template>\r\n          <ng-template kendoPanelBarContent class=\"menu-content-temp\">\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </ng-template>\r\n        </kendo-panelbar-item>\r\n      </kendo-panelbar> -->\r\n    </ion-col>\r\n  </ion-row>\r\n</ion-grid>\r\n", styles: ["ion-grid{max-width:2000px;margin-top:10px}:host ::ng-deep kendo-card{width:95%!important;margin:auto auto 10px;border-radius:var(--ion-container-border-radius);border-left:5px solid var(--ion-color-primary)}:host ::ng-deep kendo-card .k-card-body{padding-top:0}.menu-col{padding:10px}.menu-btn{margin:0;padding:0;border:0px;display:flex;flex-flow:column;justify-content:center;align-items:stretch;background-color:#fff;cursor:pointer;border-radius:5px;box-shadow:1px 1px 4px #797979;min-width:180px;max-width:250px;min-height:120px;max-height:120px;color:#fff;background:var(--ion-color-primary)}.menu-btn:hover{box-shadow:0 0 2px 2px var(--ion-color-secondary)}.menu-btn:hover .menu-btn-label-text-desc{bottom:0;transition:.5s ease bottom;width:100%}.menu-btn-label-text{text-align:center;font-size:16px;font-weight:600;padding:10px 5px}.menu-btn-label-text-desc{bottom:-100%;transition:.5s ease bottom;display:block;position:absolute;color:#000;font-size:16px;background-color:#fff;padding:8px 10px;border:1px solid #797979;border-radius:5px;text-shadow:0px 0px black;width:100%;text-align:left;font-size:14px;font-weight:500}.ripple-parent{position:relative;overflow:hidden}.menu-btn-label{text-align:center;font-size:15px}.menu-icon{zoom:3;position:relative;top:2px}.menu-btn-icon{background-size:100%}.pending-counter{background-color:#ff243a;border-radius:1em;box-sizing:border-box;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;text-overflow:ellipsis;top:12px;display:inline-block;position:absolute;text-align:center;font-size:1.4em;right:32%}\n"], components: [{ type: i4.IonGrid, selector: "ion-grid", inputs: ["fixed"] }, { type: i4.IonRow, selector: "ion-row" }, { type: i4.IonCol, selector: "ion-col", inputs: ["offset", "offsetLg", "offsetMd", "offsetSm", "offsetXl", "offsetXs", "pull", "pullLg", "pullMd", "pullSm", "pullXl", "pullXs", "push", "pushLg", "pushMd", "pushSm", "pushXl", "pushXs", "size", "sizeLg", "sizeMd", "sizeSm", "sizeXl", "sizeXs"] }, { type: i4.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { type: i5.FaIconComponent, selector: "fa-icon", inputs: ["icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "classes", "transform", "a11yRole"] }, { type: i4.IonBadge, selector: "ion-badge", inputs: ["color", "mode"] }, { type: i4.IonRippleEffect, selector: "ion-ripple-effect", inputs: ["type"] }, { type: i6.CardComponent, selector: "kendo-card", inputs: ["orientation", "width"] }, { type: i6.CardHeaderComponent, selector: "kendo-card-header" }, { type: i6.CardBodyComponent, selector: "kendo-card-body" }, { type: UiappmenucontentComponent, selector: "app-uiappmenucontent", inputs: ["items"] }], directives: [{ type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i7.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i8.DefaultClassDirective, selector: "  [ngClass], [ngClass.xs], [ngClass.sm], [ngClass.md], [ngClass.lg], [ngClass.xl],  [ngClass.lt-sm], [ngClass.lt-md], [ngClass.lt-lg], [ngClass.lt-xl],  [ngClass.gt-xs], [ngClass.gt-sm], [ngClass.gt-md], [ngClass.gt-lg]", inputs: ["ngClass", "ngClass.xs", "ngClass.sm", "ngClass.md", "ngClass.lg", "ngClass.xl", "ngClass.lt-sm", "ngClass.lt-md", "ngClass.lt-lg", "ngClass.lt-xl", "ngClass.gt-xs", "ngClass.gt-sm", "ngClass.gt-md", "ngClass.gt-lg"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.CardTitleDirective, selector: "[kendoCardTitle]" }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UiappmenucontentComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'app-uiappmenucontent', template: "<ion-grid>\r\n  <ion-row>\r\n    <ion-col [ngClass]=\"getDivClass(item)\" *ngFor=\"let item of items; index as i\">\r\n      <div *ngIf=\"item.Type !== 'dropdown-submenu'\" class=\"menu-btn ion-activatable ripple-parent\"\r\n        (click)=\"menuOnClick(item.URL, item.AppClientPath)\">\r\n        <ion-label class=\"menu-btn-label menu-btn-icon\">\r\n          <fa-icon class=\"menu-icon\" [icon]=\"['fas', item.Icon ]\" [inverse]=\"true\"></fa-icon>\r\n          <ion-badge color=\"danger\" class=\"pending-counter\"\r\n            *ngIf=\"item['PendingCounter'] && item['PendingCounter'] > 0\">\r\n            {{item['PendingCounter']}}\r\n          </ion-badge>\r\n        </ion-label>\r\n        <ion-label class=\"menu-btn-label-text\">{{ item.Label }}</ion-label>\r\n        <ion-label *ngIf=\"item.Description\" class=\"menu-btn-label-text menu-btn-label-text-desc\">{{ item.Description }}\r\n        </ion-label>\r\n        <ion-ripple-effect></ion-ripple-effect>\r\n      </div>\r\n\r\n      <kendo-card *ngIf=\"item.Type === 'dropdown-submenu'\">\r\n        <kendo-card-header class=\"k-hstack\">\r\n          <ion-label class=\"card-title\" kendoCardTitle>{{item.Label}}</ion-label>\r\n        </kendo-card-header>\r\n        <kendo-card-body>\r\n          <div class=\"k-hstack\">\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </div>\r\n        </kendo-card-body>\r\n      </kendo-card>\r\n\r\n      <!-- <kendo-panelbar class=\"menu-panel\" *ngIf=\"item.Type === 'dropdown-submenu'\" keepItemContent=\"true\">\r\n        <kendo-panelbar-item [expanded]=\"true\">\r\n          <ng-template kendoPanelBarItemTitle>\r\n            <span *ngIf=\"item.Icon\">\r\n              <fa-icon [icon]=\"item.Icon\" class=\"zcard-header-icon\"></fa-icon>\r\n            </span>\r\n            <span *ngIf=\"!item.Icon\">\r\n              <i class=\"fas fa-folder\" style=\"color: #000000\"></i>\r\n            </span>\r\n            <ion-label class=\"zcard-header-title\">{{item.Label}}</ion-label>\r\n          </ng-template>\r\n          <ng-template kendoPanelBarContent class=\"menu-content-temp\">\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </ng-template>\r\n        </kendo-panelbar-item>\r\n      </kendo-panelbar> -->\r\n    </ion-col>\r\n  </ion-row>\r\n</ion-grid>\r\n", styles: ["ion-grid{max-width:2000px;margin-top:10px}:host ::ng-deep kendo-card{width:95%!important;margin:auto auto 10px;border-radius:var(--ion-container-border-radius);border-left:5px solid var(--ion-color-primary)}:host ::ng-deep kendo-card .k-card-body{padding-top:0}.menu-col{padding:10px}.menu-btn{margin:0;padding:0;border:0px;display:flex;flex-flow:column;justify-content:center;align-items:stretch;background-color:#fff;cursor:pointer;border-radius:5px;box-shadow:1px 1px 4px #797979;min-width:180px;max-width:250px;min-height:120px;max-height:120px;color:#fff;background:var(--ion-color-primary)}.menu-btn:hover{box-shadow:0 0 2px 2px var(--ion-color-secondary)}.menu-btn:hover .menu-btn-label-text-desc{bottom:0px;transition:.5s ease bottom;width:100%}.menu-btn-label-text{text-align:center;font-size:16px;font-weight:600;padding:10px 5px}.menu-btn-label-text-desc{bottom:-100%;transition:.5s ease bottom;display:block;position:absolute;color:#000;font-size:16px;background-color:#fff;padding:8px 10px;border:1px solid #797979;border-radius:5px;text-shadow:0px 0px black;width:100%;text-align:left;font-size:14px;font-weight:500}.ripple-parent{position:relative;overflow:hidden}.menu-btn-label{text-align:center;font-size:15px}.menu-icon{zoom:3;position:relative;top:2px}.menu-btn-icon{background-size:100%}.pending-counter{background-color:#ff243a;border-radius:1em;box-sizing:border-box;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;text-overflow:ellipsis;top:12px;display:inline-block;position:absolute;text-align:center;font-size:1.4em;right:32%}\n"] }]
+            args: [{ selector: 'app-uiappmenucontent', template: "<ion-grid>\r\n  <ion-row>\r\n    <ion-col [ngClass]=\"getDivClass(item)\" *ngFor=\"let item of items; index as i\">\r\n      <div *ngIf=\"item.Type !== 'dropdown-submenu'\" class=\"menu-btn ion-activatable ripple-parent\"\r\n        (click)=\"menuOnClick(item.URL, item.AppClientPath)\">\r\n        <ion-label class=\"menu-btn-label menu-btn-icon\">\r\n          <fa-icon class=\"menu-icon\" [icon]=\"['fas', item.Icon ]\" [inverse]=\"true\"></fa-icon>\r\n          <ion-badge color=\"danger\" class=\"pending-counter\"\r\n            *ngIf=\"item['PendingCounter'] && item['PendingCounter'] > 0\">\r\n            {{item['PendingCounter']}}\r\n          </ion-badge>\r\n        </ion-label>\r\n        <ion-label class=\"menu-btn-label-text\">{{ item.Label }}</ion-label>\r\n        <ion-label *ngIf=\"item.Description\" class=\"menu-btn-label-text menu-btn-label-text-desc\">{{ item.Description }}\r\n        </ion-label>\r\n        <ion-ripple-effect></ion-ripple-effect>\r\n      </div>\r\n\r\n      <kendo-card *ngIf=\"item.Type === 'dropdown-submenu'\">\r\n        <kendo-card-header class=\"k-hstack\">\r\n          <ion-label class=\"card-title\" kendoCardTitle>{{item.Label}}</ion-label>\r\n        </kendo-card-header>\r\n        <kendo-card-body>\r\n          <div>\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </div>\r\n        </kendo-card-body>\r\n      </kendo-card>\r\n\r\n      <!-- <kendo-panelbar class=\"menu-panel\" *ngIf=\"item.Type === 'dropdown-submenu'\" keepItemContent=\"true\">\r\n        <kendo-panelbar-item [expanded]=\"true\">\r\n          <ng-template kendoPanelBarItemTitle>\r\n            <span *ngIf=\"item.Icon\">\r\n              <fa-icon [icon]=\"item.Icon\" class=\"zcard-header-icon\"></fa-icon>\r\n            </span>\r\n            <span *ngIf=\"!item.Icon\">\r\n              <i class=\"fas fa-folder\" style=\"color: #000000\"></i>\r\n            </span>\r\n            <ion-label class=\"zcard-header-title\">{{item.Label}}</ion-label>\r\n          </ng-template>\r\n          <ng-template kendoPanelBarContent class=\"menu-content-temp\">\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </ng-template>\r\n        </kendo-panelbar-item>\r\n      </kendo-panelbar> -->\r\n    </ion-col>\r\n  </ion-row>\r\n</ion-grid>\r\n", styles: ["ion-grid{max-width:2000px;margin-top:10px}:host ::ng-deep kendo-card{width:95%!important;margin:auto auto 10px;border-radius:var(--ion-container-border-radius);border-left:5px solid var(--ion-color-primary)}:host ::ng-deep kendo-card .k-card-body{padding-top:0}.menu-col{padding:10px}.menu-btn{margin:0;padding:0;border:0px;display:flex;flex-flow:column;justify-content:center;align-items:stretch;background-color:#fff;cursor:pointer;border-radius:5px;box-shadow:1px 1px 4px #797979;min-width:180px;max-width:250px;min-height:120px;max-height:120px;color:#fff;background:var(--ion-color-primary)}.menu-btn:hover{box-shadow:0 0 2px 2px var(--ion-color-secondary)}.menu-btn:hover .menu-btn-label-text-desc{bottom:0;transition:.5s ease bottom;width:100%}.menu-btn-label-text{text-align:center;font-size:16px;font-weight:600;padding:10px 5px}.menu-btn-label-text-desc{bottom:-100%;transition:.5s ease bottom;display:block;position:absolute;color:#000;font-size:16px;background-color:#fff;padding:8px 10px;border:1px solid #797979;border-radius:5px;text-shadow:0px 0px black;width:100%;text-align:left;font-size:14px;font-weight:500}.ripple-parent{position:relative;overflow:hidden}.menu-btn-label{text-align:center;font-size:15px}.menu-icon{zoom:3;position:relative;top:2px}.menu-btn-icon{background-size:100%}.pending-counter{background-color:#ff243a;border-radius:1em;box-sizing:border-box;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;text-overflow:ellipsis;top:12px;display:inline-block;position:absolute;text-align:center;font-size:1.4em;right:32%}\n"] }]
         }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.MenuService }, { type: i2.AuthService }, { type: i2.ZCoreService }, { type: i3.MainService }]; }, propDecorators: { items: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uiappmenucontent.component.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/uiappmenucontent/uiappmenucontent.component.ts","../../../../../projects/mmhglobal-dynamicform/src/lib/uiappmenucontent/uiappmenucontent.component.html"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,OAAO,EAAE,SAAS,EAAU,KAAK,EAAE,MAAM,eAAe,CAAC;AAGzD,6BAA6B;AAE7B,8BAA8B;AAE9B,2CAA2C;AAC3C,OAAO,EAA2C,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;;;;;;;;;;AAS1G,MAAM,OAAO,yBAAyB;IAEpC,YACU,MAAc,EACd,WAAwB,EACxB,WAAwB,EACxB,YAA0B,EAC1B,WAAwB;QAJxB,WAAM,GAAN,MAAM,CAAQ;QACd,gBAAW,GAAX,WAAW,CAAa;QACxB,gBAAW,GAAX,WAAW,CAAa;QACxB,iBAAY,GAAZ,YAAY,CAAc;QAC1B,gBAAW,GAAX,WAAW,CAAa;IAC9B,CAAC;IAEL,QAAQ;IACR,CAAC;IAEM,WAAW,CAAC,IAAI;QACrB,OAAO,CAAC,IAAI,CAAC,IAAI,KAAK,kBAAkB,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,qCAAqC,CAAC,GAAG,WAAW,CAAC;IAChH,CAAC;IAEM,WAAW,CAAC,IAAI;QACrB,OAAO,IAAI,CAAC,IAAI,KAAK,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5F,CAAC;IAEM,WAAW,CAAC,QAAgB,EAAE,aAAsB;QACzD,MAAM,WAAW,GAAW,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,WAAW,CAAC;QAE3E,IAAI,aAAa,IAAI,WAAW,CAAC,iBAAiB,EAAE,IAAI,UAAU,EAAE;YAClE,gBAAgB,CAAC,iBAAiB,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YAC9E,OAAO,KAAK,CAAC;SACd;aACI;YACH,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;YAC3D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;SAClC;IACH,CAAC;IAEO,WAAW,CAAC,GAAW,EAAE,KAAa;QAC5C,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACjD,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC;QACzB,QAAQ,CAAC,IAAI,GAAG,GAAG,CAAC;QACpB,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAEtC,OAAO,QAAQ,CAAC;IAClB,CAAC;;uHAzCU,yBAAyB;2GAAzB,yBAAyB,wFClBtC,i2EAgDA,gqFD9Ba,yBAAyB;4FAAzB,yBAAyB;kBALrC,SAAS;+BACE,sBAAsB;sMAKvB,KAAK;sBAAb,KAAK","sourcesContent":["/********** Angular **********/\r\nimport { Component, OnInit, Input } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\n\r\n/********** Ionic **********/\r\n\r\n/********** Plugin **********/\r\n\r\n/********** Component & Service **********/\r\nimport { OAuthMenuItem, MenuService, AuthService, ZComponentHelper, ZCoreService } from 'mmhglobal-zcore';\r\nimport { MainService } from '../services/main.service';\r\n\r\n\r\n@Component({\r\n  selector: 'app-uiappmenucontent',\r\n  templateUrl: './uiappmenucontent.component.html',\r\n  styleUrls: ['./uiappmenucontent.component.scss'],\r\n})\r\nexport class UiappmenucontentComponent implements OnInit {\r\n  @Input() items: Array<OAuthMenuItem>;\r\n  constructor(\r\n    private router: Router,\r\n    private menuService: MenuService,\r\n    private authService: AuthService,\r\n    private zcoreService: ZCoreService,\r\n    private mainService: MainService\r\n  ) { }\r\n\r\n  ngOnInit() {\r\n  }\r\n\r\n  public getDivClass(item) {\r\n    return (item.Type === 'dropdown-submenu' ? 'flex-show' : 'col-xs-4 col-sm-4 col-md-3 col-xl-2') + \" menu-col\";\r\n  }\r\n\r\n  public getMenuList(item) {\r\n    return item.Type === 'dropdown-submenu' ? this.menuService.getMenuFolder(item.URL) : null;\r\n  }\r\n\r\n  public menuOnClick(pathName: string, appClientPath?: string) {\r\n    const startupPage: string = this.zcoreService.getEnvironment().startUpPage;\r\n\r\n    if (appClientPath && startupPage.toLocaleLowerCase() == 'launcher') {\r\n      ZComponentHelper.openAppClientPath(pathName, appClientPath, this.authService);\r\n      return false;\r\n    }\r\n    else {\r\n      this.mainService.setNavigationParams([pathName, pathName]);\r\n      this.router.navigate([pathName]);\r\n    }\r\n  }\r\n\r\n  private setMapInput(key: string, value: string) {\r\n    const mapInput = document.createElement('input');\r\n    mapInput.type = 'hidden';\r\n    mapInput.name = key;\r\n    mapInput.setAttribute('value', value);\r\n\r\n    return mapInput;\r\n  }\r\n}\r\n","<ion-grid>\r\n  <ion-row>\r\n    <ion-col [ngClass]=\"getDivClass(item)\" *ngFor=\"let item of items; index as i\">\r\n      <div *ngIf=\"item.Type !== 'dropdown-submenu'\" class=\"menu-btn ion-activatable ripple-parent\"\r\n        (click)=\"menuOnClick(item.URL, item.AppClientPath)\">\r\n        <ion-label class=\"menu-btn-label menu-btn-icon\">\r\n          <fa-icon class=\"menu-icon\" [icon]=\"['fas', item.Icon ]\" [inverse]=\"true\"></fa-icon>\r\n          <ion-badge color=\"danger\" class=\"pending-counter\"\r\n            *ngIf=\"item['PendingCounter'] && item['PendingCounter'] > 0\">\r\n            {{item['PendingCounter']}}\r\n          </ion-badge>\r\n        </ion-label>\r\n        <ion-label class=\"menu-btn-label-text\">{{ item.Label }}</ion-label>\r\n        <ion-label *ngIf=\"item.Description\" class=\"menu-btn-label-text menu-btn-label-text-desc\">{{ item.Description }}\r\n        </ion-label>\r\n        <ion-ripple-effect></ion-ripple-effect>\r\n      </div>\r\n\r\n      <kendo-card *ngIf=\"item.Type === 'dropdown-submenu'\">\r\n        <kendo-card-header class=\"k-hstack\">\r\n          <ion-label class=\"card-title\" kendoCardTitle>{{item.Label}}</ion-label>\r\n        </kendo-card-header>\r\n        <kendo-card-body>\r\n          <div class=\"k-hstack\">\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </div>\r\n        </kendo-card-body>\r\n      </kendo-card>\r\n\r\n      <!-- <kendo-panelbar class=\"menu-panel\" *ngIf=\"item.Type === 'dropdown-submenu'\" keepItemContent=\"true\">\r\n        <kendo-panelbar-item [expanded]=\"true\">\r\n          <ng-template kendoPanelBarItemTitle>\r\n            <span *ngIf=\"item.Icon\">\r\n              <fa-icon [icon]=\"item.Icon\" class=\"zcard-header-icon\"></fa-icon>\r\n            </span>\r\n            <span *ngIf=\"!item.Icon\">\r\n              <i class=\"fas fa-folder\" style=\"color: #000000\"></i>\r\n            </span>\r\n            <ion-label class=\"zcard-header-title\">{{item.Label}}</ion-label>\r\n          </ng-template>\r\n          <ng-template kendoPanelBarContent class=\"menu-content-temp\">\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </ng-template>\r\n        </kendo-panelbar-item>\r\n      </kendo-panelbar> -->\r\n    </ion-col>\r\n  </ion-row>\r\n</ion-grid>\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uiappmenucontent.component.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/uiappmenucontent/uiappmenucontent.component.ts","../../../../../projects/mmhglobal-dynamicform/src/lib/uiappmenucontent/uiappmenucontent.component.html"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,OAAO,EAAE,SAAS,EAAU,KAAK,EAAE,MAAM,eAAe,CAAC;AAGzD,6BAA6B;AAE7B,8BAA8B;AAE9B,2CAA2C;AAC3C,OAAO,EAA2C,gBAAgB,EAAgB,MAAM,iBAAiB,CAAC;;;;;;;;;;AAS1G,MAAM,OAAO,yBAAyB;IAEpC,YACU,MAAc,EACd,WAAwB,EACxB,WAAwB,EACxB,YAA0B,EAC1B,WAAwB;QAJxB,WAAM,GAAN,MAAM,CAAQ;QACd,gBAAW,GAAX,WAAW,CAAa;QACxB,gBAAW,GAAX,WAAW,CAAa;QACxB,iBAAY,GAAZ,YAAY,CAAc;QAC1B,gBAAW,GAAX,WAAW,CAAa;IAC9B,CAAC;IAEL,QAAQ;IACR,CAAC;IAEM,WAAW,CAAC,IAAI;QACrB,OAAO,CAAC,IAAI,CAAC,IAAI,KAAK,kBAAkB,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,qCAAqC,CAAC,GAAG,WAAW,CAAC;IAChH,CAAC;IAEM,WAAW,CAAC,IAAI;QACrB,OAAO,IAAI,CAAC,IAAI,KAAK,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5F,CAAC;IAEM,WAAW,CAAC,QAAgB,EAAE,aAAsB;QACzD,MAAM,WAAW,GAAW,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,WAAW,CAAC;QAE3E,IAAI,aAAa,IAAI,WAAW,CAAC,iBAAiB,EAAE,IAAI,UAAU,EAAE;YAClE,gBAAgB,CAAC,iBAAiB,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YAC9E,OAAO,KAAK,CAAC;SACd;aACI;YACH,IAAI,WAAW,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE;gBACpC,YAAY;gBACZ,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;aACrD;iBACI;gBACH,YAAY;gBACZ,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;aAClD;YACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;SAClC;IACH,CAAC;IAEO,WAAW,CAAC,GAAW,EAAE,KAAa;QAC5C,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACjD,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC;QACzB,QAAQ,CAAC,IAAI,GAAG,GAAG,CAAC;QACpB,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAEtC,OAAO,QAAQ,CAAC;IAClB,CAAC;;uHAhDU,yBAAyB;2GAAzB,yBAAyB,wFClBtC,80EAgDA,8pFD9Ba,yBAAyB;4FAAzB,yBAAyB;kBALrC,SAAS;+BACE,sBAAsB;sMAKvB,KAAK;sBAAb,KAAK","sourcesContent":["/********** Angular **********/\r\nimport { Component, OnInit, Input } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\n\r\n/********** Ionic **********/\r\n\r\n/********** Plugin **********/\r\n\r\n/********** Component & Service **********/\r\nimport { OAuthMenuItem, MenuService, AuthService, ZComponentHelper, ZCoreService } from 'mmhglobal-zcore';\r\nimport { MainService } from '../services/main.service';\r\n\r\n\r\n@Component({\r\n  selector: 'app-uiappmenucontent',\r\n  templateUrl: './uiappmenucontent.component.html',\r\n  styleUrls: ['./uiappmenucontent.component.scss'],\r\n})\r\nexport class UiappmenucontentComponent implements OnInit {\r\n  @Input() items: Array<OAuthMenuItem>;\r\n  constructor(\r\n    private router: Router,\r\n    private menuService: MenuService,\r\n    private authService: AuthService,\r\n    private zcoreService: ZCoreService,\r\n    private mainService: MainService\r\n  ) { }\r\n\r\n  ngOnInit() {\r\n  }\r\n\r\n  public getDivClass(item) {\r\n    return (item.Type === 'dropdown-submenu' ? 'flex-show' : 'col-xs-4 col-sm-4 col-md-3 col-xl-2') + \" menu-col\";\r\n  }\r\n\r\n  public getMenuList(item) {\r\n    return item.Type === 'dropdown-submenu' ? this.menuService.getMenuFolder(item.URL) : null;\r\n  }\r\n\r\n  public menuOnClick(pathName: string, appClientPath?: string) {\r\n    const startupPage: string = this.zcoreService.getEnvironment().startUpPage;\r\n\r\n    if (appClientPath && startupPage.toLocaleLowerCase() == 'launcher') {\r\n      ZComponentHelper.openAppClientPath(pathName, appClientPath, this.authService);\r\n      return false;\r\n    }\r\n    else {\r\n      if (startupPage.indexOf('_', 0) == 0) {\r\n        // menu page\r\n        this.mainService.setNavigationParams([startupPage]);\r\n      }\r\n      else {\r\n        // home page\r\n        this.mainService.setNavigationParams([pathName]);\r\n      }\r\n      this.router.navigate([pathName]);\r\n    }\r\n  }\r\n\r\n  private setMapInput(key: string, value: string) {\r\n    const mapInput = document.createElement('input');\r\n    mapInput.type = 'hidden';\r\n    mapInput.name = key;\r\n    mapInput.setAttribute('value', value);\r\n\r\n    return mapInput;\r\n  }\r\n}\r\n","<ion-grid>\r\n  <ion-row>\r\n    <ion-col [ngClass]=\"getDivClass(item)\" *ngFor=\"let item of items; index as i\">\r\n      <div *ngIf=\"item.Type !== 'dropdown-submenu'\" class=\"menu-btn ion-activatable ripple-parent\"\r\n        (click)=\"menuOnClick(item.URL, item.AppClientPath)\">\r\n        <ion-label class=\"menu-btn-label menu-btn-icon\">\r\n          <fa-icon class=\"menu-icon\" [icon]=\"['fas', item.Icon ]\" [inverse]=\"true\"></fa-icon>\r\n          <ion-badge color=\"danger\" class=\"pending-counter\"\r\n            *ngIf=\"item['PendingCounter'] && item['PendingCounter'] > 0\">\r\n            {{item['PendingCounter']}}\r\n          </ion-badge>\r\n        </ion-label>\r\n        <ion-label class=\"menu-btn-label-text\">{{ item.Label }}</ion-label>\r\n        <ion-label *ngIf=\"item.Description\" class=\"menu-btn-label-text menu-btn-label-text-desc\">{{ item.Description }}\r\n        </ion-label>\r\n        <ion-ripple-effect></ion-ripple-effect>\r\n      </div>\r\n\r\n      <kendo-card *ngIf=\"item.Type === 'dropdown-submenu'\">\r\n        <kendo-card-header class=\"k-hstack\">\r\n          <ion-label class=\"card-title\" kendoCardTitle>{{item.Label}}</ion-label>\r\n        </kendo-card-header>\r\n        <kendo-card-body>\r\n          <div>\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </div>\r\n        </kendo-card-body>\r\n      </kendo-card>\r\n\r\n      <!-- <kendo-panelbar class=\"menu-panel\" *ngIf=\"item.Type === 'dropdown-submenu'\" keepItemContent=\"true\">\r\n        <kendo-panelbar-item [expanded]=\"true\">\r\n          <ng-template kendoPanelBarItemTitle>\r\n            <span *ngIf=\"item.Icon\">\r\n              <fa-icon [icon]=\"item.Icon\" class=\"zcard-header-icon\"></fa-icon>\r\n            </span>\r\n            <span *ngIf=\"!item.Icon\">\r\n              <i class=\"fas fa-folder\" style=\"color: #000000\"></i>\r\n            </span>\r\n            <ion-label class=\"zcard-header-title\">{{item.Label}}</ion-label>\r\n          </ng-template>\r\n          <ng-template kendoPanelBarContent class=\"menu-content-temp\">\r\n            <app-uiappmenucontent [items]=\"getMenuList(item)\"></app-uiappmenucontent>\r\n          </ng-template>\r\n        </kendo-panelbar-item>\r\n      </kendo-panelbar> -->\r\n    </ion-col>\r\n  </ion-row>\r\n</ion-grid>\r\n"]}

package/esm2020/lib/uibulletin/uibulletin.component.mjs

@@ -0,0 +1,91 @@
+/********** Angular **********/
+import { Component, Input, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';
+import { filter, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "mmhglobal-zcore";
+import * as i2 from "../services/main.service";
+import * as i3 from "../services/signalr.service";
+import * as i4 from "@progress/kendo-angular-notification";
+import * as i5 from "@ionic/angular";
+import * as i6 from "@fortawesome/angular-fontawesome";
+import * as i7 from "@angular/common";
+export class UibulletinComponent {
+    constructor(zcoreService, webApiService, resourceApiService, mainService, signalr, notificationService) {
+        this.zcoreService = zcoreService;
+        this.webApiService = webApiService;
+        this.resourceApiService = resourceApiService;
+        this.mainService = mainService;
+        this.signalr = signalr;
+        this.notificationService = notificationService;
+        // backNavigate = null;
+        this.bulletinMessages = [];
+        this.hideBulletinTemplate = true;
+        this.title = "";
+        this.showBulletinIcon = false;
+        this.defaultMessage = 'There are no message today.';
+        this.environment = this.zcoreService.getEnvironment();
+        this.showBulletinIcon = this.environment.bulletinUrl ? true : false;
+    }
+    ngOnInit() {
+        this.mainService.getResourceServerData().subscribe(() => {
+            this.webApiService.httpGet$(this.resourceApiService.getURL(this.environment.bulletinUrl), '').subscribe(resp => {
+                if (resp) {
+                    const msg = [];
+                    if (resp.length > 0) {
+                        resp.forEach((item) => {
+                            msg.push(item.Description);
+                        });
+                    }
+                    this.setBulletinMessages(msg);
+                }
+            });
+        });
+    }
+    ngAfterViewInit() {
+        this.getSignalrBulletinMessage().subscribe();
+    }
+    setBulletinMessages(data) {
+        if (data.length > 0) {
+            data.forEach((item) => {
+                if (item.Description) {
+                    this.bulletinMessages.push(item.Description);
+                }
+            });
+            this.title = this.bulletinMessages.length + " messages. Click to view messages.";
+        }
+        else {
+            this.title = "No message";
+        }
+    }
+    getSignalrBulletinMessage() {
+        return this.signalr.getEvent().pipe(filter(event => event.name === 'Bulletin'), map(event => {
+            this.setBulletinMessages(event.payload);
+        }));
+    }
+    showBulletinMessage() {
+        // if closable property is set to true, hideAfter property is ignored.
+        this.notificationService.show({
+            content: this.bulletinTemplate,
+            position: { horizontal: "center", vertical: "top" },
+            animation: { type: "slide", duration: 500 },
+            type: { style: "none", icon: false },
+            closable: this.bulletinMessages.length > 0 ? true : false,
+            hideAfter: 1000,
+        });
+    }
+}
+UibulletinComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UibulletinComponent, deps: [{ token: i1.ZCoreService }, { token: i1.WebApiService }, { token: i1.ResourceApiService }, { token: i2.MainService }, { token: i3.SignalrService }, { token: i4.NotificationService }], target: i0.ɵɵFactoryTarget.Component });
+UibulletinComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: UibulletinComponent, selector: "app-uibulletin", inputs: { group: "group" }, viewQueries: [{ propertyName: "appendTo", first: true, predicate: ["appendTo"], descendants: true, read: ViewContainerRef }, { propertyName: "bulletinTemplate", first: true, predicate: ["bulletinTemplate"], descendants: true, read: TemplateRef }], ngImport: i0, template: "<ion-button (click)=\"showBulletinMessage()\" fill=\"none\" size=\"small\" *ngIf=\"showBulletinIcon\">\r\n\r\n  <ion-label [title]=\"title\">\r\n    <ion-badge color=\"danger\" class=\"pending-counter\"\r\n               *ngIf=\"bulletinMessages.length > 0\">\r\n    </ion-badge>\r\n    <ion-label><fa-icon [icon]=\"['fas', 'bell']\" size=\"lg\" style=\"margin-right: 5px;\"></fa-icon> Notification</ion-label>\r\n    <ion-ripple-effect></ion-ripple-effect>\r\n  </ion-label>\r\n\r\n  <!--<fa-icon [icon]=\"['fas', 'bell']\" style=\"margin-right: 5px;\"></fa-icon> Bulletin-->\r\n</ion-button>\r\n<ng-template #bulletinTemplate>\r\n  <div *ngIf=\"bulletinMessages.length > 0\">\r\n    <!--<h6>Bulletin</h6>-->\r\n    <ul>\r\n      <li *ngFor=\"let msg of bulletinMessages\">{{ msg }}</li>\r\n    </ul>\r\n  </div>\r\n  <div *ngIf=\"bulletinMessages.length <= 0\">\r\n    {{ defaultMessage }}\r\n  </div>\r\n</ng-template>\r\n", styles: [".ripple-parent{position:relative;overflow:hidden}.pending-counterX{background-color:#ff243a;border-radius:1em;box-sizing:border-box;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;right:2px;text-overflow:ellipsis;top:2px;transform:scale(.25);transform-origin:top left;display:inline-block;position:absolute;text-align:center;font-size:2.2em}.pending-counter{background-color:#ff243a;border-radius:1em;box-sizing:border-box;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;text-overflow:ellipsis;left:8px;top:7px;transform:scale(.25);transform-origin:top left;display:inline-block;position:absolute;text-align:center;font-size:1.5em}\n"], components: [{ type: i5.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { type: i5.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { type: i5.IonBadge, selector: "ion-badge", inputs: ["color", "mode"] }, { type: i6.FaIconComponent, selector: "fa-icon", inputs: ["icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "classes", "transform", "a11yRole"] }, { type: i5.IonRippleEffect, selector: "ion-ripple-effect", inputs: ["type"] }], directives: [{ type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i7.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: UibulletinComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-uibulletin', template: "<ion-button (click)=\"showBulletinMessage()\" fill=\"none\" size=\"small\" *ngIf=\"showBulletinIcon\">\r\n\r\n  <ion-label [title]=\"title\">\r\n    <ion-badge color=\"danger\" class=\"pending-counter\"\r\n               *ngIf=\"bulletinMessages.length > 0\">\r\n    </ion-badge>\r\n    <ion-label><fa-icon [icon]=\"['fas', 'bell']\" size=\"lg\" style=\"margin-right: 5px;\"></fa-icon> Notification</ion-label>\r\n    <ion-ripple-effect></ion-ripple-effect>\r\n  </ion-label>\r\n\r\n  <!--<fa-icon [icon]=\"['fas', 'bell']\" style=\"margin-right: 5px;\"></fa-icon> Bulletin-->\r\n</ion-button>\r\n<ng-template #bulletinTemplate>\r\n  <div *ngIf=\"bulletinMessages.length > 0\">\r\n    <!--<h6>Bulletin</h6>-->\r\n    <ul>\r\n      <li *ngFor=\"let msg of bulletinMessages\">{{ msg }}</li>\r\n    </ul>\r\n  </div>\r\n  <div *ngIf=\"bulletinMessages.length <= 0\">\r\n    {{ defaultMessage }}\r\n  </div>\r\n</ng-template>\r\n", styles: [".ripple-parent{position:relative;overflow:hidden}.pending-counterX{background-color:#ff243a;border-radius:1em;box-sizing:border-box;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;right:2px;text-overflow:ellipsis;top:2px;transform:scale(.25);transform-origin:top left;display:inline-block;position:absolute;text-align:center;font-size:2.2em}.pending-counter{background-color:#ff243a;border-radius:1em;box-sizing:border-box;color:#fff;height:1.5em;line-height:1;max-width:5em;min-width:1.5em;overflow:hidden;padding:.25em;text-overflow:ellipsis;left:8px;top:7px;transform:scale(.25);transform-origin:top left;display:inline-block;position:absolute;text-align:center;font-size:1.5em}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ZCoreService }, { type: i1.WebApiService }, { type: i1.ResourceApiService }, { type: i2.MainService }, { type: i3.SignalrService }, { type: i4.NotificationService }]; }, propDecorators: { appendTo: [{
+                type: ViewChild,
+                args: ['appendTo', { read: ViewContainerRef }]
+            }], bulletinTemplate: [{
+                type: ViewChild,
+                args: ['bulletinTemplate', { read: TemplateRef }]
+            }], group: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uibulletin.component.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/uibulletin/uibulletin.component.ts","../../../../../projects/mmhglobal-dynamicform/src/lib/uibulletin/uibulletin.component.html"],"names":[],"mappings":"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","sourcesContent":["/********** Angular **********/\r\nimport { Component, OnInit, Input, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';\r\n\r\n/********** Ionic **********/\r\n\r\n/********** Plugin **********/\r\nimport { NotificationService } from '@progress/kendo-angular-notification';\r\nimport { Observable, of } from 'rxjs';\r\nimport { filter, map, switchMap, tap } from 'rxjs/operators';\r\n\r\n/********** Component & Service **********/\r\n// import { ZComponentDebugService } from '../services/zcomponent.debug.service';\r\nimport { ZGroup, ZCoreService, WebApiService, ResourceApiService } from 'mmhglobal-zcore';\r\nimport { SignalrService } from '../services/signalr.service';\r\nimport { MainService } from '../services/main.service';\r\n\r\n\r\n@Component({\r\n  selector: 'app-uibulletin',\r\n  templateUrl: './uibulletin.component.html',\r\n  styleUrls: ['./uibulletin.component.scss'],\r\n})\r\nexport class UibulletinComponent implements OnInit {\r\n  @ViewChild('appendTo', { read: ViewContainerRef }) public appendTo: ViewContainerRef;\r\n  @ViewChild('bulletinTemplate', { read: TemplateRef }) bulletinTemplate: TemplateRef<any>;\r\n  @Input() group: ZGroup;\r\n  // backNavigate = null;\r\n  public bulletinMessages = [];\r\n  public hideBulletinTemplate = true;\r\n  public title = \"\";\r\n  public showBulletinIcon = false;\r\n  public defaultMessage = 'There are no message today.';\r\n  public environment: any;\r\n  public firstInitBulletinURL: string;\r\n\r\n  constructor(\r\n    private zcoreService: ZCoreService,\r\n    private webApiService: WebApiService,\r\n    private resourceApiService: ResourceApiService,\r\n    private mainService: MainService,\r\n    private signalr: SignalrService,\r\n    private notificationService: NotificationService\r\n  ) {\r\n    this.environment = this.zcoreService.getEnvironment();\r\n    this.showBulletinIcon = this.environment.bulletinUrl ? true : false;\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.mainService.getResourceServerData().subscribe(() => {\r\n      this.webApiService.httpGet$(this.resourceApiService.getURL(this.environment.bulletinUrl), '').subscribe(resp => {\r\n        if (resp) {\r\n          const msg = [];\r\n          if (resp.length > 0) {\r\n            resp.forEach((item: any) => {\r\n              msg.push(item.Description);\r\n            })\r\n          }\r\n          this.setBulletinMessages(msg);\r\n        }\r\n      })\r\n    });\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    this.getSignalrBulletinMessage().subscribe();\r\n  }\r\n\r\n  public setBulletinMessages(data: any[]) {\r\n    if (data.length > 0) {\r\n      data.forEach((item: any) => {\r\n        if (item.Description) {\r\n          this.bulletinMessages.push(item.Description);\r\n        }\r\n      })\r\n      this.title = this.bulletinMessages.length + \" messages. Click to view messages.\";\r\n    }\r\n    else {\r\n      this.title = \"No message\";\r\n    }\r\n  }\r\n\r\n  public getSignalrBulletinMessage(): Observable<any> {\r\n    return this.signalr.getEvent().pipe(\r\n      filter(event => event.name === 'Bulletin'),\r\n      map(event => {\r\n        this.setBulletinMessages(event.payload);\r\n      }));\r\n  }\r\n\r\n  public showBulletinMessage(): void { \r\n    // if closable property is set to true, hideAfter property is ignored.\r\n    this.notificationService.show({\r\n      content: this.bulletinTemplate,\r\n      position: { horizontal: \"center\", vertical: \"top\" },\r\n      animation: { type: \"slide\", duration: 500 },\r\n      type: { style: \"none\", icon: false },\r\n      closable: this.bulletinMessages.length > 0 ? true : false,\r\n      hideAfter: 1000,\r\n    });\r\n  }\r\n}\r\n","<ion-button (click)=\"showBulletinMessage()\" fill=\"none\" size=\"small\" *ngIf=\"showBulletinIcon\">\r\n\r\n  <ion-label [title]=\"title\">\r\n    <ion-badge color=\"danger\" class=\"pending-counter\"\r\n               *ngIf=\"bulletinMessages.length > 0\">\r\n    </ion-badge>\r\n    <ion-label><fa-icon [icon]=\"['fas', 'bell']\" size=\"lg\" style=\"margin-right: 5px;\"></fa-icon> Notification</ion-label>\r\n    <ion-ripple-effect></ion-ripple-effect>\r\n  </ion-label>\r\n\r\n  <!--<fa-icon [icon]=\"['fas', 'bell']\" style=\"margin-right: 5px;\"></fa-icon> Bulletin-->\r\n</ion-button>\r\n<ng-template #bulletinTemplate>\r\n  <div *ngIf=\"bulletinMessages.length > 0\">\r\n    <!--<h6>Bulletin</h6>-->\r\n    <ul>\r\n      <li *ngFor=\"let msg of bulletinMessages\">{{ msg }}</li>\r\n    </ul>\r\n  </div>\r\n  <div *ngIf=\"bulletinMessages.length <= 0\">\r\n    {{ defaultMessage }}\r\n  </div>\r\n</ng-template>\r\n"]}