common-header-lib 0.0.1

package/esm2020/lib/common-header-lib.module.mjs

@@ -0,0 +1,208 @@
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ReactiveFormsModule } from '@angular/forms';
+import { HttpClient, HttpClientModule } from '@angular/common/http';
+import { TranslateLoader, TranslateModule, TranslateService, } from '@ngx-translate/core';
+import { TranslateHttpLoader } from '@ngx-translate/http-loader';
+/* PrimeNG */
+import { InputTextModule } from 'primeng/inputtext';
+import { DropdownModule } from 'primeng/dropdown';
+import { OverlayPanelModule } from 'primeng/overlaypanel';
+import { BadgeModule } from 'primeng/badge';
+import { DialogModule } from 'primeng/dialog';
+import { SkeletonModule } from 'primeng/skeleton';
+import { PaginatorModule } from 'primeng/paginator';
+import { TableModule } from 'primeng/table';
+import { ButtonModule } from 'primeng/button';
+import { ConfirmDialogModule } from 'primeng/confirmdialog';
+/* Bootstrap */
+import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
+/* Components */
+import { CommonHeaderLibComponent } from './common-header-lib.component';
+import { SidePopupComponent } from './components/side-popup/side-popup.component';
+import { UserSidebarComponent } from './components/user-sidebar/user-sidebar.component';
+import { NgTranslationComponent } from './components/ng-translation/ng-translation.component';
+import { UserMailboxComponent } from './components/user-mailbox/user-mailbox.component';
+import { NotificationSidebarComponent } from './components/notification-sidebar/notification-sidebar.component';
+import { GeneralConfigurationComponent } from './components/general-configuration/general-configuration.component';
+import { LandingpgConfigComponent } from './components/general-configuration/landingpg-config/landingpg-config.component';
+import { TimezoneConfigurationComponent } from './components/general-configuration/timezone-configuration/timezone-configuration.component';
+import { NoServiceMyAccessPgComponent } from './components/no-service-my-access-pg/no-service-my-access-pg.component';
+import { GridPaginationComponent } from './components/grid-pagination/grid-pagination.component';
+import { ConfirmDialogComponent } from './components/confirm-dialog/confirm-dialog.component';
+import { ViewpasswordPopupComponent } from './components/viewpassword-popup/viewpassword-popup.component';
+/* Pipes */
+import { SliceToTwoPipe } from './pipes/slice-to-two.pipe';
+import { customDateFormatPipe } from './pipes/custome-dateformat.pipe';
+import { DateDiffPipe } from './pipes/date-diff.pipe';
+import { COOKIECONSTANT, GlobalConstants } from './model/data_model';
+import { StorageService } from './services/storage.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class CommonHeaderLibModule {
+}
+CommonHeaderLibModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CommonHeaderLibModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CommonHeaderLibModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: CommonHeaderLibModule, declarations: [CommonHeaderLibComponent,
+        SliceToTwoPipe,
+        customDateFormatPipe,
+        DateDiffPipe,
+        UserSidebarComponent,
+        SidePopupComponent,
+        NgTranslationComponent,
+        UserMailboxComponent,
+        NotificationSidebarComponent,
+        GeneralConfigurationComponent,
+        TimezoneConfigurationComponent,
+        LandingpgConfigComponent,
+        NoServiceMyAccessPgComponent,
+        GridPaginationComponent,
+        ConfirmDialogComponent,
+        ViewpasswordPopupComponent], imports: [CommonModule,
+        HttpClientModule,
+        ReactiveFormsModule,
+        /* UI Modules */
+        InputTextModule,
+        DropdownModule,
+        OverlayPanelModule,
+        BadgeModule,
+        DialogModule,
+        SkeletonModule,
+        PaginatorModule,
+        TableModule,
+        ButtonModule,
+        ConfirmDialogModule,
+        NgbModule, i1.TranslateModule], exports: [CommonHeaderLibComponent,
+        SliceToTwoPipe,
+        DateDiffPipe,
+        customDateFormatPipe,
+        ConfirmDialogComponent,
+        ViewpasswordPopupComponent,
+        TranslateModule] });
+CommonHeaderLibModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CommonHeaderLibModule, providers: [
+        {
+            provide: APP_INITIALIZER,
+            useFactory: initTranslateService,
+            deps: [TranslateService, StorageService],
+            multi: true,
+        },
+    ], imports: [CommonModule,
+        HttpClientModule,
+        ReactiveFormsModule,
+        /* UI Modules */
+        InputTextModule,
+        DropdownModule,
+        OverlayPanelModule,
+        BadgeModule,
+        DialogModule,
+        SkeletonModule,
+        PaginatorModule,
+        TableModule,
+        ButtonModule,
+        ConfirmDialogModule,
+        NgbModule,
+        /* ngx-translate (isolated for library) */
+        TranslateModule.forChild({
+            loader: {
+                provide: TranslateLoader,
+                useFactory: createLibTranslateLoader,
+                deps: [HttpClient],
+            },
+            isolate: true,
+        }), TranslateModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CommonHeaderLibModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        CommonHeaderLibComponent,
+                        SliceToTwoPipe,
+                        customDateFormatPipe,
+                        DateDiffPipe,
+                        UserSidebarComponent,
+                        SidePopupComponent,
+                        NgTranslationComponent,
+                        UserMailboxComponent,
+                        NotificationSidebarComponent,
+                        GeneralConfigurationComponent,
+                        TimezoneConfigurationComponent,
+                        LandingpgConfigComponent,
+                        NoServiceMyAccessPgComponent,
+                        GridPaginationComponent,
+                        ConfirmDialogComponent,
+                        ViewpasswordPopupComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        ReactiveFormsModule,
+                        /* UI Modules */
+                        InputTextModule,
+                        DropdownModule,
+                        OverlayPanelModule,
+                        BadgeModule,
+                        DialogModule,
+                        SkeletonModule,
+                        PaginatorModule,
+                        TableModule,
+                        ButtonModule,
+                        ConfirmDialogModule,
+                        NgbModule,
+                        /* ngx-translate (isolated for library) */
+                        TranslateModule.forChild({
+                            loader: {
+                                provide: TranslateLoader,
+                                useFactory: createLibTranslateLoader,
+                                deps: [HttpClient],
+                            },
+                            isolate: true,
+                        }),
+                    ],
+                    exports: [
+                        CommonHeaderLibComponent,
+                        SliceToTwoPipe,
+                        DateDiffPipe,
+                        customDateFormatPipe,
+                        ConfirmDialogComponent,
+                        ViewpasswordPopupComponent,
+                        TranslateModule,
+                    ],
+                    providers: [
+                        {
+                            provide: APP_INITIALIZER,
+                            useFactory: initTranslateService,
+                            deps: [TranslateService, StorageService],
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+export function initTranslateService(translate, localStorageService) {
+    return () => {
+        const supportedLangs = GlobalConstants.USERLANGUAGES;
+        const defaultLang = GlobalConstants.DEFAULTLANG;
+        let selectedLang = defaultLang;
+        /* 1. Read from localStorage */
+        const saved = localStorageService.getData(COOKIECONSTANT.USERLANG);
+        if (saved) {
+            try {
+                const parsed = JSON.parse(saved);
+                const isValid = supportedLangs.some((lang) => lang.langKey === parsed?.langKey);
+                if (isValid) {
+                    selectedLang = parsed;
+                }
+            }
+            catch {
+                // corrupted JSON → fallback to default
+                selectedLang = defaultLang;
+            }
+        }
+        /* 2. Persist corrected value */
+        localStorageService.saveData(COOKIECONSTANT.USERLANG, JSON.stringify(selectedLang));
+        /* 3. Apply language */
+        translate.setDefaultLang(selectedLang.langKey);
+        return translate.use(selectedLang.langKey).subscribe();
+    };
+}
+export function createLibTranslateLoader(http) {
+    return new TranslateHttpLoader(http, 'assets/common-header-lib/i18n/', '.json');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-header-lib.module.js","sourceRoot":"","sources":["../../../../projects/common-header-lib/src/lib/common-header-lib.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { APP_INITIALIZER, NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { HttpClient, HttpClientModule } from '@angular/common/http';\n\nimport {\n  TranslateLoader,\n  TranslateModule,\n  TranslateService,\n} from '@ngx-translate/core';\nimport { TranslateHttpLoader } from '@ngx-translate/http-loader';\n\n/* PrimeNG */\nimport { InputTextModule } from 'primeng/inputtext';\nimport { DropdownModule } from 'primeng/dropdown';\nimport { OverlayPanelModule } from 'primeng/overlaypanel';\nimport { BadgeModule } from 'primeng/badge';\nimport { DialogModule } from 'primeng/dialog';\nimport { SkeletonModule } from 'primeng/skeleton';\nimport { PaginatorModule } from 'primeng/paginator';\nimport { TableModule } from 'primeng/table';\nimport { ButtonModule } from 'primeng/button';\nimport { ConfirmDialogModule } from 'primeng/confirmdialog';\n\n/* Bootstrap */\nimport { NgbModule } from '@ng-bootstrap/ng-bootstrap';\n\n/* Components */\nimport { CommonHeaderLibComponent } from './common-header-lib.component';\nimport { SidePopupComponent } from './components/side-popup/side-popup.component';\nimport { UserSidebarComponent } from './components/user-sidebar/user-sidebar.component';\nimport { NgTranslationComponent } from './components/ng-translation/ng-translation.component';\nimport { UserMailboxComponent } from './components/user-mailbox/user-mailbox.component';\nimport { NotificationSidebarComponent } from './components/notification-sidebar/notification-sidebar.component';\nimport { GeneralConfigurationComponent } from './components/general-configuration/general-configuration.component';\nimport { LandingpgConfigComponent } from './components/general-configuration/landingpg-config/landingpg-config.component';\nimport { TimezoneConfigurationComponent } from './components/general-configuration/timezone-configuration/timezone-configuration.component';\nimport { NoServiceMyAccessPgComponent } from './components/no-service-my-access-pg/no-service-my-access-pg.component';\nimport { GridPaginationComponent } from './components/grid-pagination/grid-pagination.component';\nimport { ConfirmDialogComponent } from './components/confirm-dialog/confirm-dialog.component';\nimport { ViewpasswordPopupComponent } from './components/viewpassword-popup/viewpassword-popup.component';\n\n/* Pipes */\nimport { SliceToTwoPipe } from './pipes/slice-to-two.pipe';\nimport { customDateFormatPipe } from './pipes/custome-dateformat.pipe';\nimport { DateDiffPipe } from './pipes/date-diff.pipe';\nimport { COOKIECONSTANT, GlobalConstants } from './model/data_model';\nimport { StorageService } from './services/storage.service';\n\n@NgModule({\n  declarations: [\n    CommonHeaderLibComponent,\n    SliceToTwoPipe,\n    customDateFormatPipe,\n    DateDiffPipe,\n    UserSidebarComponent,\n    SidePopupComponent,\n    NgTranslationComponent,\n    UserMailboxComponent,\n    NotificationSidebarComponent,\n    GeneralConfigurationComponent,\n    TimezoneConfigurationComponent,\n    LandingpgConfigComponent,\n    NoServiceMyAccessPgComponent,\n    GridPaginationComponent,\n    ConfirmDialogComponent,\n    ViewpasswordPopupComponent,\n  ],\n  imports: [\n    CommonModule,\n    HttpClientModule,\n    ReactiveFormsModule,\n\n    /* UI Modules */\n    InputTextModule,\n    DropdownModule,\n    OverlayPanelModule,\n    BadgeModule,\n    DialogModule,\n    SkeletonModule,\n    PaginatorModule,\n    TableModule,\n    ButtonModule,\n    ConfirmDialogModule,\n    NgbModule,\n\n    /* ngx-translate (isolated for library) */\n    TranslateModule.forChild({\n      loader: {\n        provide: TranslateLoader,\n        useFactory: createLibTranslateLoader,\n        deps: [HttpClient],\n      },\n      isolate: true,\n    }),\n  ],\n  exports: [\n    CommonHeaderLibComponent,\n    SliceToTwoPipe,\n    DateDiffPipe,\n    customDateFormatPipe,\n    ConfirmDialogComponent,\n    ViewpasswordPopupComponent,\n    TranslateModule,\n  ],\n  providers: [\n    {\n      provide: APP_INITIALIZER,\n      useFactory: initTranslateService,\n      deps: [TranslateService, StorageService],\n      multi: true,\n    },\n  ],\n})\nexport class CommonHeaderLibModule {}\n\nexport function initTranslateService(\n  translate: TranslateService,\n  localStorageService: StorageService,\n) {\n  return () => {\n    const supportedLangs = GlobalConstants.USERLANGUAGES;\n    const defaultLang = GlobalConstants.DEFAULTLANG;\n\n    let selectedLang = defaultLang;\n\n    /* 1. Read from localStorage */\n    const saved = localStorageService.getData(COOKIECONSTANT.USERLANG);\n\n    if (saved) {\n      try {\n        const parsed = JSON.parse(saved);\n\n        const isValid = supportedLangs.some(\n          (lang) => lang.langKey === parsed?.langKey,\n        );\n\n        if (isValid) {\n          selectedLang = parsed;\n        }\n      } catch {\n        // corrupted JSON → fallback to default\n        selectedLang = defaultLang;\n      }\n    }\n\n    /* 2. Persist corrected value */\n    localStorageService.saveData(\n      COOKIECONSTANT.USERLANG,\n      JSON.stringify(selectedLang),\n    );\n    /* 3. Apply language */\n    translate.setDefaultLang(selectedLang.langKey);\n    return translate.use(selectedLang.langKey).subscribe();\n  };\n}\n\nexport function createLibTranslateLoader(http: HttpClient) {\n  return new TranslateHttpLoader(\n    http,\n    'assets/common-header-lib/i18n/',\n    '.json',\n  );\n}\n"]}

package/esm2020/lib/common-header-lib.service.mjs

@@ -0,0 +1,200 @@
+import { Injectable } from '@angular/core';
+import { catchError, map } from 'rxjs/operators';
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { throwError } from 'rxjs';
+import { GlobalConstants } from './model/data_model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class CommonHeaderLibService {
+    constructor(http) {
+        this.http = http;
+        this.apiUrl = '';
+    }
+    getGlobalTimeZone() {
+        return this.http
+            .get(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/GetSystemTimeZones')
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'];
+            }
+            else {
+                return [];
+            }
+        }));
+    }
+    getLoggedInUserDetails(url) {
+        return this.http
+            .post(url + 'xaccess/api/SecureAccess/GetUsersDetailsById', {})
+            .pipe(map((response) => {
+            // return response['result'];
+            return response;
+        }));
+    }
+    getLOBList(url) {
+        return this.http.get(url + 'meta/api/metadata/Lobs').pipe(map((response) => {
+            let result = [];
+            if (response['statusCode'] === 200) {
+                // let result = response['result'];
+                let result = response;
+                return result;
+            }
+        }));
+    }
+    getUserAssignedApps(url) {
+        return this.http
+            .post(url + 'xaccess/api/SecureAccess/GetUserPriviledgesList', {})
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'].filter((x) => x.appCode != null
+                // (x) => x.appCode !== 'APP026' && x.appCode != null
+                );
+            }
+            else {
+                return [];
+            }
+        }));
+    }
+    getUnreadUserEmailsCount(url) {
+        return this.http.get(url + 'xservice/api/CIInfraAsset/MailBoxCount').pipe(map((response) => {
+            if (response && response['success'] && response['result'] > 0) {
+                return response['result'];
+            }
+            else {
+                return 0;
+            }
+        }));
+    }
+    getUserAssignedMails(userDetails, url) {
+        return this.http
+            .post(url + 'xservice/api/CIInfraAsset/MailBox', userDetails)
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'];
+            }
+            else {
+                return [];
+            }
+        }));
+    }
+    getWorkFlowTicketEventwiseCount(userDetails, url) {
+        return this.http
+            .post(url + 'workflow/api/Workflow/Workflow/GetWorkFlowTicketCountEventWise', userDetails)
+            .pipe(map((response) => {
+            if (response && response[0]['Success']) {
+                return response[0]['Data'];
+            }
+            else {
+                return [];
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    errorHandler(e) {
+        throw new Error('Method not implemented.');
+    }
+    getUserPreferredAssetTypeDetails(url) {
+        return this.http
+            .get(url + 'xaccess/api/PagePreference/GetAssetTypeDetails')
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'];
+            }
+            else {
+                return [];
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    getUserPreferredAssetName(payload, url) {
+        return this.http
+            .post(url + 'xaccess/api/PagePreference/GetAssetName', payload)
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'];
+            }
+            else {
+                return [];
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    getServiceNameByAssetTypeEvent(payload, url) {
+        return this.http
+            .post(url + 'xaccess/api/PagePreference/GetServiceDetails', payload)
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'];
+            }
+            else {
+                return [];
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    getPreferencePathDetails(payload, url) {
+        return this.http
+            .post(url + 'xaccess/api/PagePreference/CurrentPreferencepathDetails', payload)
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'];
+            }
+            else {
+                return {};
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    updatePreferencePath(payload, url) {
+        return this.http
+            .post(url + 'xaccess/api/PagePreference/UpdatePreferencePath', payload)
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    updateUserTimeZone(tz, url) {
+        const params = new HttpParams().set('timezone', tz);
+        return this.http
+            .post(url + 'xaccess/api/SecureAccess/UpdateTimeZone', {}, { params: params })
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'];
+            }
+            else {
+                return '';
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    setLandingPgPreference(moduleId, url) {
+        return this.http
+            .post(url + 'xaccess/api/SecureAccess/SetLandingPage', {
+            moduleId: moduleId,
+        })
+            .pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'];
+            }
+            else {
+                return '';
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+    getInitiateUserLogout() {
+        return this.http.post(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/logout', {}).pipe(map((response) => {
+            if (response && response['success']) {
+                return response['result'];
+            }
+            else {
+                return {};
+            }
+        }), catchError((e) => throwError(this.errorHandler(e))));
+    }
+}
+CommonHeaderLibService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CommonHeaderLibService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+CommonHeaderLibService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CommonHeaderLibService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CommonHeaderLibService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-header-lib.service.js","sourceRoot":"","sources":["../../../../projects/common-header-lib/src/lib/common-header-lib.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { catchError, map } from 'rxjs/operators';\nimport { HttpClient, HttpParams } from '@angular/common/http';\nimport { throwError } from 'rxjs';\nimport { GlobalConstants } from './model/data_model';\n@Injectable({\n  providedIn: 'root',\n})\nexport class CommonHeaderLibService {\n  apiUrl: string = '';\n  constructor(private readonly http: HttpClient) {}\n  getGlobalTimeZone() {\n    return this.http\n      .get(\n        GlobalConstants.baseURL + 'xaccess/api/SecureAccess/GetSystemTimeZones'\n      )\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return response['result'];\n          } else {\n            return [];\n          }\n        })\n      );\n  }\n  getLoggedInUserDetails(url: string) {\n    return this.http\n      .post(url + 'xaccess/api/SecureAccess/GetUsersDetailsById', {})\n      .pipe(\n        map((response: any) => {\n          // return response['result'];\n          return response;\n        })\n      );\n  }\n  getLOBList(url: string) {\n    return this.http.get(url + 'meta/api/metadata/Lobs').pipe(\n      map((response: any) => {\n        let result = [];\n        if (response['statusCode'] === 200) {\n          // let result = response['result'];\n          let result = response;\n          return result;\n        }\n      })\n    );\n  }\n  getUserAssignedApps(url: string) {\n    return this.http\n      .post(url + 'xaccess/api/SecureAccess/GetUserPriviledgesList', {})\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return response['result'].filter(\n              (x: any) => x.appCode != null\n              // (x) => x.appCode !== 'APP026' && x.appCode != null\n            );\n          } else {\n            return [];\n          }\n        })\n      );\n  }\n  getUnreadUserEmailsCount(url: string) {\n    return this.http.get(url + 'xservice/api/CIInfraAsset/MailBoxCount').pipe(\n      map((response: any) => {\n        if (response && response['success'] && response['result'] > 0) {\n          return response['result'];\n        } else {\n          return 0;\n        }\n      })\n    );\n  }\n  getUserAssignedMails(userDetails: any, url: string) {\n    return this.http\n      .post(url + 'xservice/api/CIInfraAsset/MailBox', userDetails)\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return response['result'];\n          } else {\n            return [];\n          }\n        })\n      );\n  }\n  getWorkFlowTicketEventwiseCount(userDetails: any, url: string) {\n    return this.http\n      .post(\n        url + 'workflow/api/Workflow/Workflow/GetWorkFlowTicketCountEventWise',\n        userDetails\n      )\n      .pipe(\n        map((response: any) => {\n          if (response && response[0]['Success']) {\n            return response[0]['Data'];\n          } else {\n            return [];\n          }\n        }),\n        catchError((e) => throwError(this.errorHandler(e)))\n      );\n  }\n  errorHandler(e: any): any {\n    throw new Error('Method not implemented.');\n  }\n  getUserPreferredAssetTypeDetails(url: string) {\n    return this.http\n      .get(url + 'xaccess/api/PagePreference/GetAssetTypeDetails')\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return response['result'];\n          } else {\n            return [];\n          }\n        }),\n        catchError((e) => throwError(this.errorHandler(e)))\n      );\n  }\n  getUserPreferredAssetName(payload: any, url: string) {\n    return this.http\n      .post(url + 'xaccess/api/PagePreference/GetAssetName', payload)\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return response['result'];\n          } else {\n            return [];\n          }\n        }),\n        catchError((e) => throwError(this.errorHandler(e)))\n      );\n  }\n  getServiceNameByAssetTypeEvent(payload: any, url: string) {\n    return this.http\n      .post(url + 'xaccess/api/PagePreference/GetServiceDetails', payload)\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return response['result'];\n          } else {\n            return [];\n          }\n        }),\n        catchError((e) => throwError(this.errorHandler(e)))\n      );\n  }\n  getPreferencePathDetails(payload: any, url: string) {\n    return this.http\n      .post(\n        url + 'xaccess/api/PagePreference/CurrentPreferencepathDetails',\n        payload\n      )\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return response['result'];\n          } else {\n            return {};\n          }\n        }),\n        catchError((e) => throwError(this.errorHandler(e)))\n      );\n  }\n  updatePreferencePath(payload: any, url: string) {\n    return this.http\n      .post(url + 'xaccess/api/PagePreference/UpdatePreferencePath', payload)\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return true;\n          } else {\n            return false;\n          }\n        }),\n        catchError((e) => throwError(this.errorHandler(e)))\n      );\n  }\n\n  updateUserTimeZone(tz: string, url: string) {\n    const params = new HttpParams().set('timezone', tz);\n    return this.http\n      .post(\n        url + 'xaccess/api/SecureAccess/UpdateTimeZone',\n        {},\n        { params: params }\n      )\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return response['result'];\n          } else {\n            return '';\n          }\n        }),\n        catchError((e) => throwError(this.errorHandler(e)))\n      );\n  }\n  setLandingPgPreference(moduleId: string, url: string) {\n    return this.http\n      .post(url + 'xaccess/api/SecureAccess/SetLandingPage', {\n        moduleId: moduleId,\n      })\n      .pipe(\n        map((response: any) => {\n          if (response && response['success']) {\n            return response['result'];\n          } else {\n            return '';\n          }\n        }),\n        catchError((e) => throwError(this.errorHandler(e)))\n      );\n  }\n  getInitiateUserLogout() {\n    return this.http.post(GlobalConstants.baseURL + 'xaccess/api/SecureAccess/logout', {}).pipe(\n      map((response: any) => {\n        if (response && response['success']) {\n          return response['result'];\n        } else {\n          return {};\n        }\n      }),\n      catchError((e) => throwError(this.errorHandler(e)))\n    );\n  }\n}\n"]}

package/esm2020/lib/components/confirm-dialog/confirm-dialog.component.mjs

@@ -0,0 +1,49 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { ConfirmationService } from 'primeng/api';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+import * as i2 from "primeng/confirmdialog";
+export class ConfirmDialogComponent {
+    constructor(confirmationService) {
+        this.confirmationService = confirmationService;
+        this.header = '';
+        this.message = '';
+        this.result = new EventEmitter();
+    }
+    openConfirmModal(event) {
+        this.confirmationService.confirm({
+            target: event.target,
+            message: this.message,
+            header: this.header,
+            closeOnEscape: true,
+            // icon: 'pi pi-exclamation-triangle',
+            // ✔ PrimeNG 14 button config
+            acceptLabel: 'Yes',
+            rejectLabel: 'No',
+            acceptButtonStyleClass: 'p-button-primary',
+            rejectButtonStyleClass: 'p-button-secondary p-button-outlined',
+            accept: () => {
+                this.result.emit(true);
+            },
+            reject: () => {
+                this.result.emit(false);
+            },
+        });
+    }
+}
+ConfirmDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ConfirmDialogComponent, deps: [{ token: i1.ConfirmationService }], target: i0.ɵɵFactoryTarget.Component });
+ConfirmDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: ConfirmDialogComponent, selector: "confirm-dialog", inputs: { header: "header", message: "message" }, outputs: { result: "result" }, providers: [ConfirmationService], ngImport: i0, template: "<div class=\"card flex justify-center gap-2 view-pass-details confirmtion-modal\">\n  <p-confirmDialog icon=\"none\" acceptIcon=\"\" rejectIcon=\"\"></p-confirmDialog>\n</div>\n", styles: [""], dependencies: [{ kind: "component", type: i2.ConfirmDialog, selector: "p-confirmDialog", inputs: ["header", "icon", "message", "style", "styleClass", "maskStyleClass", "acceptIcon", "acceptLabel", "acceptAriaLabel", "acceptVisible", "rejectIcon", "rejectLabel", "rejectAriaLabel", "rejectVisible", "acceptButtonStyleClass", "rejectButtonStyleClass", "closeOnEscape", "dismissableMask", "blockScroll", "rtl", "closable", "appendTo", "key", "autoZIndex", "baseZIndex", "transitionOptions", "focusTrap", "defaultFocus", "breakpoints", "visible", "position"], outputs: ["onHide"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: ConfirmDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'confirm-dialog', providers: [ConfirmationService], template: "<div class=\"card flex justify-center gap-2 view-pass-details confirmtion-modal\">\n  <p-confirmDialog icon=\"none\" acceptIcon=\"\" rejectIcon=\"\"></p-confirmDialog>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ConfirmationService }]; }, propDecorators: { header: [{
+                type: Input,
+                args: ['header']
+            }], message: [{
+                type: Input,
+                args: ['message']
+            }], result: [{
+                type: Output,
+                args: ['result']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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