@tsi-developpement/tsi-shared-ui 0.0.1

package/esm2022/lib/tsi-components/manage-reporting/manage-reporting.component.mjs

@@ -0,0 +1,1075 @@
+import { Component, Input, ViewChild } from '@angular/core';
+import { TooltipPosition } from '../../enums/tooltipPosition.enum';
+import { ButtonType } from '../../enums/button-type.enum';
+import { AddReportPopupComponent } from './add-report-popup/add-report-popup.component';
+import { firstValueFrom } from 'rxjs';
+import { LocalizationKeys } from '../../consts/localization-key';
+import { Segment } from '../../end-points';
+import { GridSelectionMode, TsiReportType, DisplayTypes, CSSUnits, ModalSizeEnum, Modes } from '../../enums';
+import { CSSSizeProperty } from '../../interfaces';
+import { AppRoutes } from '../../routes/app.routes';
+import { TsiFormComponentBaseComponent } from '../../tsi-base/components/tsi-form-base/tsi-form-base.component';
+import { ReportingEndpoints } from '../../end-points/reporting-endpoints';
+import { queryParamNamesConst } from '../../consts/queryParamNames.const';
+import { ManageReportingRoutes } from '../../routes/manage-reporting.routes';
+import { appProviders } from '../../consts/app-providers';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services";
+import * as i2 from "primeng/dynamicdialog";
+import * as i3 from "@angular/router";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "primeng/api";
+import * as i7 from "primeng/toolbar";
+import * as i8 from "primeng/dialog";
+import * as i9 from "primeng/dropdown";
+import * as i10 from "primeng/fileupload";
+import * as i11 from "../input-components/tsi-search-combo/tsi-search-combo.component";
+import * as i12 from "../output-components/tsi-label/tsi-label.component";
+import * as i13 from "../output-components/tsi-view-grid/tsi-view-grid.component";
+import * as i14 from "../button-components/tsi-button/tsi-button.component";
+import * as i15 from "../../tsi-directives/busy.directive";
+import * as i16 from "../../pipes/localize.pipe";
+export class ManageReportingComponent extends TsiFormComponentBaseComponent {
+    static { this.reportTypeLabels = {
+        [TsiReportType.Dashboard]: 'Dashboard',
+        [TsiReportType.List]: 'End user',
+        [TsiReportType.RTF]: 'RTF',
+    }; }
+    get isReportForFiche() {
+        return !this.otherFormEndpoint?.includes('getallpaged') && !this.requestData;
+    }
+    //#endregion
+    //#region Output properties
+    //@Output() hide: EventEmitter<void> = new EventEmitter<void>();
+    //#endregion
+    //#region ctor
+    constructor(
+    // public _parametresApplicationPaieService: ParametresApplicationPaieService,
+    reportingService, identityManagerService, confirmationService, notificationService, ref, config, _tsiModalService, router) {
+        super(ref, config);
+        this.reportingService = reportingService;
+        this.identityManagerService = identityManagerService;
+        this.confirmationService = confirmationService;
+        this.notificationService = notificationService;
+        this.ref = ref;
+        this.config = config;
+        this._tsiModalService = _tsiModalService;
+        this.router = router;
+        //#region properties
+        this.EDITION_PERSONNALISE = 'app-edition-personnalise';
+        this.reports = [];
+        this.toUploadFileData = undefined;
+        this.columns = [];
+        this.isFromForm = false;
+        this.formNames = [];
+        this.selectedReports = [];
+        this.selectionMode = GridSelectionMode.Multiple;
+        this.getFormNamesEndpoint = ReportingEndpoints.getAvailableFormNames();
+        this.globalFilterFields = ['name'];
+        this.previousFormName = '';
+        this.isUpdateReportFromFileDialogVisible = false;
+        this.toUploadToUpdateReportFileData = undefined;
+        this.defaultReportTemplateData = [];
+        this.defaultTemplateColumns = [];
+        this.tooltipPosition = TooltipPosition;
+        this.isEditionPersonnalise = false;
+        this._isReportForFiche = false;
+        this.errorMessageKey = 'shared_reporting_error_occured';
+        this.dashboardModuleRoute = `${AppRoutes.app}/${AppRoutes.dashboard}`;
+        //#endregion
+        this.buttonType = ButtonType;
+        this.isFormEndpointPaged = false;
+        //init columns
+        this.columns = [
+            {
+                field: 'name',
+                header: 'shared_reporting_report_name',
+            },
+            {
+                field: 'reportTypeName',
+                header: 'shared_reporting_report_type',
+            },
+            {
+                field: 'isDefault',
+                header: 'shared_reporting_report_isdefault',
+                type: DisplayTypes.CHECKBOX_DISPLAY,
+                width: new CSSSizeProperty(10, CSSUnits.PRECENT),
+            },
+            {
+                header: '',
+                field: 'send',
+                isButton: true,
+                buttonIcon: 'pi pi-send',
+                styleClass: 'p-button-text p-button-success',
+                toolTipText: 'shared_send_report_by_email',
+            },
+            {
+                header: '',
+                field: 'edit',
+                isButton: true,
+                buttonIcon: 'pi pi-file-edit',
+                styleClass: 'p-button-text p-button-success',
+                toolTipText: 'shared_reporting_edit',
+            },
+            {
+                header: '',
+                field: 'view',
+                isButton: true,
+                buttonIcon: 'pi pi-eye',
+                styleClass: 'p-button-text p-button-info',
+                toolTipText: 'shared_reporting_view',
+            },
+            {
+                header: '',
+                field: 'export',
+                isButton: true,
+                buttonIcon: 'pi pi-file-export',
+                styleClass: 'p-button-text p-button-help',
+                toolTipText: 'shared_reporting_export',
+            },
+            {
+                header: '',
+                field: 'import',
+                isButton: true,
+                buttonIcon: 'pi pi-paperclip',
+                styleClass: 'p-button-text p-button-warning',
+                toolTipText: 'shared_reporting_import',
+            },
+            {
+                header: '',
+                field: 'default',
+                isButton: true,
+                buttonIcon: 'pi pi-bookmark-fill',
+                styleClass: 'p-button-text',
+                toolTipText: 'shared_reporting_set_default',
+            },
+            {
+                header: '',
+                field: 'delete',
+                isButton: true,
+                buttonIcon: 'pi pi-trash',
+                styleClass: 'p-button-text p-button-danger',
+                toolTipText: 'shared_reporting_delete_report',
+            },
+            {
+                header: '',
+                field: 'Add_To_BuiltIn_Templates',
+                isButton: true,
+                buttonIcon: 'pi pi-arrow-circle-down',
+                styleClass: 'p-button-text p-button-help',
+                toolTipText: 'shared_reporting_export_dev_report',
+            },
+            {
+                header: '',
+                field: 'Make_default_report_layout',
+                isButton: true,
+                buttonIcon: 'pi pi-bookmark-fill',
+                styleClass: 'p-button-text p-button-danger',
+                toolTipText: 'shared_reporting_make_default_report_layout',
+            },
+        ];
+        this.defaultTemplateColumns = [
+            {
+                field: 'name',
+                header: 'shared_reporting_report_name',
+            },
+            {
+                field: 'reportTypeName',
+                header: 'shared_reporting_report_type',
+            },
+            {
+                header: '',
+                field: 'deleteDefaultReportFile',
+                isButton: true,
+                buttonIcon: 'pi pi-trash',
+                styleClass: 'p-button-text p-button-danger',
+                toolTipText: 'shared_reporting_delete_default_report',
+            },
+            {
+                header: '',
+                field: 'Add_From_BuiltIn_Templates',
+                isButton: true,
+                buttonIcon: 'pi pi-arrow-circle-up',
+                styleClass: 'p-button-text p-button-primary',
+                toolTipText: 'shared_reporting_add_to_my_list_report',
+            },
+        ];
+    }
+    //#endregion
+    checkIfIsDevMode() {
+        if (Segment.production) {
+            let buttonAdBuiltinTemplatesIndex = this.columns.findIndex((col) => {
+                return col.field == 'Add_To_BuiltIn_Templates';
+            });
+            if (buttonAdBuiltinTemplatesIndex != -1) {
+                this.columns.splice(buttonAdBuiltinTemplatesIndex, 1);
+            }
+            let buttonDeleteDefaultReportFileIndex = this.defaultTemplateColumns.findIndex((col) => {
+                return col.field == 'deleteDefaultReportFile';
+            });
+            if (buttonDeleteDefaultReportFileIndex != -1) {
+                this.defaultTemplateColumns.splice(buttonDeleteDefaultReportFileIndex, 1);
+            }
+        }
+    }
+    //handle Lifecycle Hooks
+    async ngOnInit() {
+        this.isEditionPersonnalise = this.router.url.includes('administration');
+        this.checkIfIsDevMode();
+        super.ngOnInit();
+        // if (this.otherFormName ) {
+        this.isFromForm = true;
+        this.columns.splice(3, 0, {
+            header: '',
+            field: 'print',
+            isButton: true,
+            buttonIcon: 'pi pi-print',
+            styleClass: 'p-button-text p-button-secondary',
+            toolTipText: 'shared_reporting_report_print',
+        });
+        if (this.otherFormName && this.otherFormName != 'app-manage-reporting') {
+            this.formNames = [{ key: this.otherFormName, value: this.otherFormName }];
+        }
+        this.entityId = this.config.data?.id;
+        this.customReportingMode = this.config?.data?.customReportingMode;
+        this.httpMethodType = this.config?.data?.httpMethodType;
+        await this._refreshReports(true);
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        if (this.refreshJobTimeOut) {
+            clearTimeout(this.refreshJobTimeOut);
+        }
+    }
+    //#endregion
+    //#region handle events
+    async onRefresh() {
+        await this._refreshReports(true);
+    }
+    onPrintDefault(event) {
+        if (this.otherFormName) {
+            this.reportingService.getDefaultReport(this.otherFormName).subscribe({
+                next: (data) => {
+                    // let defaultReportId: string = data;
+                    this._viewReport(data.uid);
+                },
+                error: (error) => { },
+            });
+        }
+    }
+    onFileSelected(event) {
+        const file = event.currentFiles[0];
+        this.toUploadFileData = file;
+    }
+    onImportFile(event) {
+        this.reportingService.uploadReportFile(this.toUploadFileData, this.reportDiscriminator).subscribe({
+            next: async (response) => {
+                await this._refreshReports();
+                this.notificationService.success('shared_reporting_report_uploaded_successfully');
+                this.fileUpload?.clear();
+            },
+            error: () => {
+                this.notificationService.error(this.errorMessageKey);
+            },
+        });
+    }
+    //cancel button click
+    onClear(event) {
+        this.toUploadFileData = undefined;
+    }
+    //cancel button click
+    onRemove(event) {
+        this.toUploadFileData = undefined;
+    }
+    handleButtonColumnClicked(event) {
+        switch (event.field) {
+            case 'send': {
+                console.log('send');
+                this._sendReport(event.key);
+                break;
+            }
+            case 'edit': {
+                console.log('edit');
+                this._editReport(event.key);
+                break;
+            }
+            case 'view': {
+                console.log('view');
+                this._viewDashboardt(event.key);
+                break;
+            }
+            case 'delete': {
+                console.log('delete');
+                this._deleteReport(event.key);
+                break;
+            }
+            case 'print': {
+                console.log('print');
+                this._viewReport(event.key);
+                break;
+            }
+            case 'export': {
+                console.log('export');
+                this._exportReport(event.key);
+                break;
+            }
+            case 'default': {
+                console.log('default');
+                this._setDefaultReport(event.key);
+                break;
+            }
+            case 'import': {
+                console.log('import');
+                this._importToReport(event.key);
+                break;
+            }
+            case 'Add_From_BuiltIn_Templates': {
+                console.log('Add_From_BuiltIn_Templates');
+                this._addFromBuiltInTemplates(event.key);
+                break;
+            }
+            case 'Add_To_BuiltIn_Templates': {
+                console.log('Add_To_BuiltIn_Templates');
+                this._addToBuiltInTemplates(event.key);
+                break;
+            }
+            case 'preview': {
+                console.log('preview');
+                this.previewBuiltInReportTemplate(event.key);
+                break;
+            }
+            case 'Make_default_report_layout': {
+                this.makeReportDefaultLayout(event.key);
+                break;
+            }
+            case 'deleteDefaultReportFile': {
+                this.deleteDefaultReportFile(event.key);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    deleteDefaultReportFile(fileName) {
+        this.confirmationService.confirm(LocalizationKeys.confirmDelete, undefined, (result) => {
+            if (result && result == true) {
+                this.isloading = true;
+                let formName = this.otherFormName ?? this.EDITION_PERSONNALISE;
+                this.reportingService
+                    .deleteDefaultReportTemplateFile(formName, fileName)
+                    .subscribe({
+                    next: async () => {
+                        await this._refreshReports(true);
+                        this.notificationService.success(LocalizationKeys.deletedSuccessfully);
+                        this.isloading = false;
+                    },
+                    error: () => {
+                        this.notificationService.error(this.errorMessageKey);
+                        this.isloading = false;
+                    },
+                });
+            }
+        });
+    }
+    onDeleteSelectedReports() {
+        this.confirmationService.confirm(LocalizationKeys.confirmDelete, undefined, (result) => {
+            if (result &&
+                this.selectedReports != null &&
+                this.selectedReports != undefined) {
+                this.isloading = true;
+                this.reportingService
+                    .deleteMultipleReports(this.selectedReports)
+                    .subscribe({
+                    next: async () => {
+                        await this._refreshReports();
+                        this.notificationService.success(LocalizationKeys.deletedSuccessfully);
+                        this.isloading = false;
+                    },
+                    error: (error) => {
+                        this.notificationService.error(this.errorMessageKey);
+                        this.isloading = false;
+                    },
+                });
+            }
+        });
+    }
+    onNewReport() {
+        if ((this.otherFormEndpoint && this.otherFormName) ||
+            this.isEditionPersonnalise) {
+            let reportToTemplateId;
+            let modalSize = ModalSizeEnum.Large;
+            let config = {
+                maximizable: true,
+                width: modalSize.width,
+                height: modalSize.height,
+                data: {
+                    mode: Modes.create,
+                    isEditionPersonnalise: this.isEditionPersonnalise,
+                    fromEndpoint: this.otherFormEndpoint,
+                    businessClass: this.businessClass,
+                    customReportingMode: this.customReportingMode
+                },
+            };
+            this._dialogRef = this._tsiModalService.open(AddReportPopupComponent, config);
+            this._dialogRef.onClose.subscribe((val) => {
+                if (val === null || val === undefined)
+                    return;
+                console.log(val);
+                if (this.isReportForFiche) {
+                    val.endPointValue = val?.endPointValue?.replace('{id}', this.entityId);
+                    val.endPointKey = val?.endPointKey?.replace('{id}', this.entityId);
+                }
+                this.reportingService
+                    .addReportToModel(this._newReportToTemplate(val.reportType, val.reportName, val.endPointValue, val.module, val.triOrdre, val.reportNameAbrege, val.display))
+                    .subscribe({
+                    next: (value) => {
+                        this.isloading = true;
+                        reportToTemplateId = value;
+                        let urlDesigner;
+                        let tenantUid = this.identityManagerService.parseMyAuthToken()?.tenantUid;
+                        if (val.reportType === TsiReportType.List) {
+                            urlDesigner = `${Segment.reportingServiceBase}/report-designer/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;
+                        }
+                        else if (val.reportType === TsiReportType.Dashboard) {
+                            urlDesigner = `${Segment.appBaseHref}/${this.dashboardModuleRoute}/${ManageReportingRoutes.dashboardDesigner}?${queryParamNamesConst.reportToTemplate}=${reportToTemplateId}&${queryParamNamesConst.tenantUid}=${tenantUid}`;
+                        }
+                        else if (val.reportType === TsiReportType.RTF) {
+                            urlDesigner = `${Segment.reportingServiceBase}/mailmerge/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;
+                        }
+                        window.open(urlDesigner, '_blank');
+                        this.notificationService.success('shared_reporting_redirected_to_new_report_successfully');
+                        this.isloading = false;
+                    },
+                    error: () => {
+                        this.isloading = false;
+                        this.notificationService.error(this.errorMessageKey);
+                    },
+                });
+                this._closeModal(val);
+            });
+        }
+    }
+    _closeModal(val) {
+        if (this._dialogRef) {
+            this._dialogRef.destroy();
+        }
+    }
+    async onFormChange() {
+        await this._refreshReports();
+    }
+    onImportFileToReportModalCancelClick() {
+        this._hideImportFileToReportDialog();
+    }
+    onImportFileToReportModalSaveClick() {
+        this._showImportFileToReportDialog();
+    }
+    //#region file import
+    onImportFileToReport_FileSelected(event) {
+        const file = event.currentFiles[0];
+        this.toUploadToUpdateReportFileData = file;
+    }
+    onImportFileToReport_ImportFile(event) {
+        if (this.selectedReportToUpdateFromFile) {
+            this.reportingService
+                .updateReportLayout(this.selectedReportToUpdateFromFile, this.toUploadToUpdateReportFileData)
+                .subscribe({
+                next: async (response) => {
+                    await this._refreshReports();
+                    this.notificationService.success('shared_reporting_report_uploaded_successfully');
+                    this.importFileToReportFileUpload?.clear();
+                    this._hideImportFileToReportDialog();
+                },
+                error: () => {
+                    this.notificationService.error(this.errorMessageKey);
+                },
+            });
+        }
+    }
+    //cancel button click
+    onImportFileToReport_Clear(event) {
+        this.toUploadToUpdateReportFileData = undefined;
+    }
+    //cancel button click
+    onImportFileToReport_Remove(event) {
+        this.toUploadToUpdateReportFileData = undefined;
+    }
+    //#endregion
+    //#endregion
+    //#region private methods
+    getFormName(formName) {
+        if (this.config?.data?.reportDiscriminator)
+            return `${formName}_${this.config.data.reportDiscriminator}`;
+        else
+            return formName;
+    }
+    async _refreshReports(refreshReportList = false) {
+        this.isloading = true;
+        let formName = this.otherFormName
+            ? this.otherFormName
+            : this.EDITION_PERSONNALISE;
+        try {
+            let items = await firstValueFrom(this.reportingService.getReports(formName, this.reportDiscriminator));
+            this.reports = items.map((r) => {
+                return {
+                    ...r,
+                    reportTypeName: ManageReportingComponent.reportTypeLabels[r.reportType] ||
+                        'Unknown',
+                };
+            });
+            this.isloading = false;
+        }
+        catch (error) {
+            this.notificationService.error(this.errorMessageKey);
+            this.isloading = false;
+        }
+        if (refreshReportList) {
+            try {
+                //get default report templates for this form
+                let result = await firstValueFrom(this.reportingService.getDefaultReportTemplate(formName));
+                this.defaultReportTemplateData = result?.data;
+            }
+            catch (error) {
+            }
+        }
+    }
+    _viewReport(uid) {
+        // if (this.otherFormEndpoint && uid) {
+        this.isloading = true;
+        let report = this.reports.find((r) => r.uid === uid);
+        if (report === undefined || report === null) {
+            this.notificationService.error(this.errorMessageKey);
+            return;
+        }
+        this.reportingService
+            .addReportToPrint(this._newReportToPrint(uid, report.reportType, report?.restEndpoint))
+            .subscribe({
+            next: (data) => {
+                let reportToTemplateId = data.uid;
+                let urlDesigner;
+                let tenantUid = this.identityManagerService.parseMyAuthToken()?.tenantUid;
+                if (data.reportType === TsiReportType.List) {
+                    urlDesigner = `${Segment.reportingServiceBase}/report-viewer/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;
+                }
+                else if (data.reportType === TsiReportType.Dashboard) {
+                    urlDesigner = `${Segment.appBaseHref}/${this.dashboardModuleRoute}/${ManageReportingRoutes.dashboardDesigner}?${queryParamNamesConst.reportToPrint}=${reportToTemplateId}&${queryParamNamesConst.tenantUid}=${tenantUid}`;
+                }
+                window.open(urlDesigner, '_blank');
+                this.notificationService.success('shared_reporting_redirected_to_print_report_successfully');
+                this.isloading = false;
+            },
+            error: (error) => {
+                this.notificationService.error(this.errorMessageKey);
+                this.isloading = false;
+            },
+            complete: () => { },
+        });
+        // }
+    }
+    _sendReport(uid) {
+        // this.isloading = true;
+        //get email parameters
+        // this._parametresApplicationPaieService
+        //   .getParametreApplicationPaie()
+        //   .subscribe((data) => {
+        //     this.parametre = data;
+        //   });
+        // let report = this.reports.find((r) => r.uid === uid);
+        // if (report === undefined || report === null) {
+        //   this.notificationService.error(this.errorMessageKey);
+        //   return;
+        // }
+        // this.reportingService
+        //   .addReportToPrint(
+        //     this._newReportToPrint(uid, report.reportType, report?.restEndpoint)
+        //   )
+        //   .subscribe({
+        //     next: (data: any) => {
+        //       if (data != null && data != undefined) {
+        //         this.reportToPrintId = data.uid;
+        //         let modalSize = ModalSizeEnum.ExtraLarge;
+        //         let saveSubject: Subject<any> = new Subject();
+        //         let conf: DynamicDialogConfig = {
+        //           data: { saveSubject },
+        //           maximizable: true,
+        //           width: modalSize.width,
+        //           height: modalSize.height,
+        //         };
+        //         this._dialogRef = this._dialogService.open(
+        //           TsiSendMailComponent,
+        //           conf
+        //         );
+        //         saveSubject.subscribe((val: any) => {
+        //           this.reportingService
+        //             .exportReportFileToPdf(this.reportToPrintId!.toString())
+        //             .subscribe(
+        //               (blob) => {
+        //                 if (!this.parametre.attachments) {
+        //                   this.parametre.attachments = [];
+        //                 }
+        //                 const newFile = new File([blob], 'Report.pdf', {
+        //                   type: blob.type,
+        //                 });
+        //                 this.parametre.attachments.push(newFile);
+        //                 this._parametresApplicationPaieService
+        //                   .sendMail(
+        //                     this.parametre.fromAddress,
+        //                     this._dialogDataService.getData()?.toAddress,
+        //                     this._dialogDataService.getData()?.objet,
+        //                     this._dialogDataService.getData()?.message,
+        //                     this.parametre.attachments,
+        //                     this.parametre.host,
+        //                     this.parametre.credentialUser,
+        //                     this.parametre.credentialPWD,
+        //                     this.parametre.port,
+        //                     this.parametre.fromName,
+        //                     this._dialogDataService.getData()?.ccAddress
+        //                   )
+        //                   .subscribe({
+        //                     next: () => {
+        //                       this.notificationService.info(
+        //                         this.localization.transform(
+        //                           LocalizationKeys.savedSuccessfully
+        //                         )
+        //                       );
+        //                       this.isloading = false;
+        //                     },
+        //                     error: (response: HttpErrorResponse) => {
+        //                       console.log(response);
+        //                       this._errorResponseManagerService.showErrorMessage(
+        //                         response
+        //                       );
+        //                     },
+        //                   });
+        //               },
+        //               (error) => {
+        //                 console.error('Error downloading the PDF', error);
+        //               }
+        //             );
+        //           this.notificationService.success(
+        //             'shared_reporting_redirected_to_print_report_successfully'
+        //           );
+        //         });
+        //         this._dialogRef.onClose.subscribe((val?: any) => {
+        //           this._closeModal(val);
+        //         });
+        //       }
+        //     },
+        //     error: (error) => {
+        //       this.notificationService.error(this.errorMessageKey);
+        //       this.isloading = false;
+        //     },
+        //     complete: () => { },
+        //   });
+    }
+    _editReport(uid) {
+        this.isloading = true;
+        let report = this.reports.find((r) => r.uid === uid);
+        if (report === undefined || report === null) {
+            this.notificationService.error(this.errorMessageKey);
+            return;
+        }
+        this.reportingService
+            .addReportToEditTemplate(this._newReportToEditTemplate(uid, report.reportType, report?.restEndpoint, report?.module, report?.order, report?.reportName, report?.shortName, report?.display))
+            .subscribe({
+            next: (value) => {
+                console.log(value);
+                if (this.isReportForFiche) {
+                    const guidRegex = /[0-9a-fA-F-]{36}/;
+                    value.restEndpoint = value?.restEndpoint?.replace(guidRegex, '{id}');
+                }
+                let config = {
+                    maximizable: true,
+                    width: ModalSizeEnum.Large.width,
+                    height: ModalSizeEnum.Large.height,
+                    data: {
+                        value: value,
+                        mode: Modes.edit,
+                        isEditionPersonnalise: this.isEditionPersonnalise,
+                        fromEndpoint: this.otherFormEndpoint
+                            ? this.otherFormEndpoint
+                            : report?.restEndpoint,
+                        businessClass: this.businessClass,
+                    },
+                };
+                this._dialogRef = this._tsiModalService.open(AddReportPopupComponent, config);
+                this._dialogRef.onClose.subscribe((val) => {
+                    if (val === null || val === undefined)
+                        return;
+                    console.log(val);
+                    let model = {
+                        reportTemplateUid: uid,
+                        reportName: val.reportName,
+                        restEndpoint: this.isReportForFiche
+                            ? this.reportingService.insertNewUidInRestEndPoint(val?.endPointValue, this.id) ?? this.otherFormEndpoint
+                            : this.otherFormEndpoint,
+                        module: val.module,
+                        order: val.triOrdre,
+                        shortName: val.reportNameAbrege,
+                        display: val.display,
+                    };
+                    this.reportingService.editReportToEditTemplate(model).subscribe();
+                    let reportToTemplateId = value.uid;
+                    let urlDesigner;
+                    let tenantUid = this.identityManagerService.parseMyAuthToken()?.tenantUid;
+                    let canredirect = localStorage.getItem('canRedirect');
+                    if (value.reportType === TsiReportType.List) {
+                        urlDesigner = `${Segment.reportingServiceBase}/report-designer-edit/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;
+                    }
+                    else if (value.reportType === TsiReportType.Dashboard) {
+                        urlDesigner = `${Segment.appBaseHref}/${this.dashboardModuleRoute}/${ManageReportingRoutes.dashboardDesigner}?${queryParamNamesConst.reportToEdit}=${reportToTemplateId}&${queryParamNamesConst.tenantUid}=${tenantUid}`;
+                    }
+                    else if (value.reportType === TsiReportType.RTF) {
+                        urlDesigner = `${Segment.reportingServiceBase}/mailmerge-edit/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;
+                    }
+                    if (canredirect && JSON.parse(canredirect) == true) {
+                        window.open(urlDesigner, '_blank');
+                    }
+                    this.notificationService.success('shared_reporting_redirected_to_edit_report_successfully');
+                });
+                this.isloading = false;
+            },
+            error: () => {
+                this.notificationService.error(this.errorMessageKey);
+                this.isloading = false;
+            },
+        });
+    }
+    _deleteReport(uid) {
+        this.confirmationService.confirm(LocalizationKeys.confirmDelete, undefined, (result) => {
+            if (result && uid != null && uid != undefined) {
+                this.isloading = true;
+                this.reportingService.deleteReport(uid).subscribe({
+                    next: async () => {
+                        this.notificationService.success(LocalizationKeys.deletedSuccessfully);
+                        await this._refreshReports();
+                        this.isloading = false;
+                    },
+                    error: (error) => {
+                        this.isloading = false;
+                        this.notificationService.error(this.errorMessageKey);
+                    },
+                });
+            }
+        });
+    }
+    _setDefaultReport(id) {
+        this.confirmationService.confirm('shared_reporting_confirm_set_default_report_file', undefined, (result) => {
+            if (result && id != null && id != undefined) {
+                this.isloading = true;
+                this.reportingService.setDefaultReport(id).subscribe({
+                    next: async () => {
+                        this.notificationService.success(LocalizationKeys.savedSuccessfully);
+                        await this._refreshReports();
+                        this.isloading = false;
+                    },
+                    error: (error) => {
+                        this.isloading = false;
+                        this.notificationService.error(this.errorMessageKey);
+                    },
+                });
+            }
+        });
+    }
+    _exportReport(uid) {
+        if (uid) {
+            let reportName = 'file-name.json';
+            let report = this.reports.find((r) => r.uid == uid);
+            if (report) {
+                reportName = report.name;
+            }
+            this.isloading = true;
+            this.reportingService.exportReportFile(uid).subscribe({
+                next: (response) => {
+                    let file = new Blob([response], { type: 'application/json' });
+                    var fileURL = URL.createObjectURL(file);
+                    let reportRoute = fileURL;
+                    var downloadLink = document.createElement('a');
+                    downloadLink.download = reportName;
+                    downloadLink.href = reportRoute;
+                    downloadLink.click();
+                    this.notificationService.success('shared_reporting_report_exported_successfully');
+                    this.isloading = false;
+                },
+                error: () => {
+                    this.notificationService.error(this.errorMessageKey);
+                    this.isloading = false;
+                },
+            });
+        }
+    }
+    _importToReport(id) {
+        if (id) {
+            this.selectedReportToUpdateFromFile = id;
+            this._showImportFileToReportDialog();
+        }
+    }
+    _newJsonDataConnection() {
+        if (this.otherFormEndpoint != null && this.otherFormEndpoint != undefined) {
+            let newJsonDataConnection = {
+                name: `${this.otherFormName}-JsonDS`,
+                displayName: undefined,
+                uri: this.otherFormEndpoint,
+                httpRequestContent: undefined,
+            };
+            return newJsonDataConnection;
+        }
+        else {
+            throw Error('some of the required properties : uri have not been set !');
+        }
+    }
+    _newReportToPrint(uid, reportType, restEndpoint, module, order, shortName, display) {
+        let token = this.identityManagerService.getAuthToken();
+        let username = this.identityManagerService.parseMyAuthToken().name;
+        if (username) {
+            if (uid && /*this.otherFormEndpoint && this.otherFormName &&*/ token) {
+                let newReportToPrint = {
+                    reportTemplateUid: uid,
+                    restEndpoint: this.isReportForFiche
+                        ? this.reportingService.insertNewUidInRestEndPoint(restEndpoint, this.id) ??
+                            this.otherFormEndpoint
+                        : this.otherFormEndpoint,
+                    requestData: !this.customReportingMode ? this.formEndpointBody : this.requestData,
+                    formName: this.otherFormName,
+                    reportType: reportType,
+                    username: username,
+                    userToken: reportType == TsiReportType.Dashboard ? undefined : token,
+                    isPaged: this.isFormEndpointPaged == true ? true : false,
+                    htmlFiltersText: this.filtersHtmlTemplate,
+                    optionalEndpointsJson: this.optionalEndpoints,
+                    module: module,
+                    order: order,
+                    shortName: shortName,
+                    display: display,
+                    httpMethodType: this.httpMethodType
+                };
+                return newReportToPrint;
+            }
+            else {
+                throw Error('some of the required properties : user token, formName, formEndpoint or selectedReport have not been set !');
+            }
+        }
+        else {
+            throw Error("property 'UserName ' of current user have not been set !");
+        }
+    }
+    _newReportToTemplate(reportType, reportName, restEndpoint, module, order, shortName, display) {
+        let token = this.identityManagerService.getAuthToken();
+        if (this.otherFormEndpoint && this.otherFormName && token) {
+            let reportToTemplate = {
+                restEndpoint: restEndpoint,
+                requestData: !this.customReportingMode ? this.formEndpointBody :
+                    this.requestData,
+                formEntity: this.otherFormName, //this.getFormName(this.otherFormName), //this.otherFormName,
+                userToken: reportType == TsiReportType.Dashboard ? undefined : token,
+                reportName: reportName,
+                isPaged: this.isFormEndpointPaged == true ? true : false,
+                reportType: reportType, //this.isFormEndpointPaged == true ? TsiReportType.List : TsiReportType.Form,
+                optionalEndpointsJson: this.optionalEndpoints,
+                htmlFiltersText: this.filtersHtmlTemplate,
+                module: module,
+                order: order,
+                shortName: shortName,
+                display: display,
+                descriminatorValue: this.reportDiscriminator,
+                httpMethodType: this.httpMethodType
+            };
+            console.log(reportToTemplate);
+            return reportToTemplate;
+        }
+        else {
+            let reportToTemplate = {
+                restEndpoint: this.isReportForFiche || this.customReportingMode
+                    ? restEndpoint
+                    : this.otherFormEndpoint,
+                requestData: !this.customReportingMode ? JSON.stringify({
+                    sorting: [{ property: 'UID', order: 'ASC' }],
+                    getAllData: true,
+                }) : this.requestData,
+                formEntity: '',
+                userToken: reportType == TsiReportType.Dashboard ? undefined : token,
+                reportName: reportName,
+                isPaged: this.isFormEndpointPaged == true ? true : false,
+                reportType: reportType, //this.isFormEndpointPaged == true ? TsiReportType.List : TsiReportType.Form,
+                optionalEndpointsJson: this.optionalEndpoints,
+                htmlFiltersText: this.filtersHtmlTemplate,
+                module: module,
+                order: order,
+                shortName: shortName,
+                display: display,
+            };
+            return reportToTemplate;
+            // throw Error('some of the required properties : user token, formName or formEndpoint have not been set !');
+        }
+    }
+    _newReportToEditTemplate(uid, reportType, restEndPoint, module, order, reportName, shortName, display) {
+        let token = this.identityManagerService.getAuthToken();
+        let username = this.identityManagerService.parseMyAuthToken().name;
+        if (username) {
+            if (uid && /*this.otherFormEndpoint && this.otherFormName &&*/ token) {
+                let reportToEditTemplate = {
+                    restEndpoint: this.isReportForFiche
+                        ? this.reportingService.insertNewUidInRestEndPoint(restEndPoint, this.id) ??
+                            this.otherFormEndpoint
+                        : this.otherFormEndpoint,
+                    requestData: !this.customReportingMode ? this.formEndpointBody : this.requestData,
+                    formName: this.otherFormName, // this.getFormName(this.otherFormName!),
+                    reportTemplateUid: uid,
+                    reportType: reportType,
+                    username: username,
+                    userToken: reportType == TsiReportType.Dashboard ? undefined : token,
+                    isPaged: this.isFormEndpointPaged == true ? true : false,
+                    optionalEndpointsJson: this.optionalEndpoints,
+                    htmlFiltersText: this.filtersHtmlTemplate,
+                    module: module,
+                    order: order,
+                    reportName: reportName,
+                    shortName: shortName,
+                    display: display,
+                    httpMethodType: this.httpMethodType
+                };
+                return reportToEditTemplate;
+            }
+            else {
+                throw Error('some of the required properties : user token or selectedReport have not been set !');
+            }
+        }
+        else {
+            this.isloading = false;
+            throw Error("property 'UserName ' of current user have not been set !");
+        }
+    }
+    _refreshReportsJob() {
+        console.warn('Refresh Reports Job at : ', new Date());
+        //
+        if (this.otherFormName != null && this.otherFormName != undefined) {
+            this.reportingService.getReports(this.otherFormName, this.reportDiscriminator).subscribe({
+                next: (items) => {
+                    this.reports = items;
+                    if (this.previousFormName != this.otherFormName) {
+                        this.notificationService.success(LocalizationKeys.retrievedSuccessfully);
+                        this.previousFormName = this.otherFormName ?? '';
+                    }
+                    //
+                    this.refreshJobTimeOut = setTimeout(() => {
+                        this._refreshReportsJob();
+                    }, 10000);
+                },
+                error: (err) => {
+                    this.notificationService.error(this.errorMessageKey);
+                    this.refreshJobTimeOut = setTimeout(() => {
+                        this._refreshReportsJob();
+                    }, 10000);
+                },
+                complete: () => { },
+            });
+        }
+        else {
+            this.refreshJobTimeOut = setTimeout(() => {
+                this._refreshReportsJob();
+            }, 10000);
+        }
+    }
+    _showImportFileToReportDialog() {
+        this.isUpdateReportFromFileDialogVisible = true;
+    }
+    _hideImportFileToReportDialog() {
+        this.isUpdateReportFromFileDialogVisible = false;
+        this.toUploadToUpdateReportFileData = undefined;
+    }
+    // getDefaultReportTemplate(){
+    previewBuiltInReportTemplate(templateName) {
+        let url = `${Segment.reportingServiceBase}/report-viewer/${this.otherFormName}/${templateName}`;
+        window.open(url, '_blank');
+    }
+    //add a report from the built-in model to the user list
+    _addFromBuiltInTemplates(templateName) {
+        let formName = this.otherFormName ?? this.EDITION_PERSONNALISE;
+        this.reportingService
+            .addFromBuiltInTemplate(formName, templateName, this.reportDiscriminator)
+            .subscribe({
+            next: async (res) => {
+                if (res && res.isSuccess === true) {
+                    await this._refreshReports();
+                    this.notificationService.info(res.msg);
+                }
+                else
+                    this.notificationService.warn('shared_reporting_cannot_add_from_built_in_template');
+            },
+            error: (err) => {
+                this.notificationService.warn('shared_reporting_cannot_add_from_built_in_template');
+            },
+        });
+    }
+    //add a report from the user list to built-in model template
+    _addToBuiltInTemplates(reportId) {
+        this.reportingService.addToBuiltInTemplate(reportId).subscribe({
+            next: async (res) => {
+                await this._refreshReports(true);
+                this.notificationService.info(LocalizationKeys.savedSuccessfully);
+            },
+            error: (err) => {
+                this.notificationService.warn('shared_reporting_add_to_builtin_template_report_failed');
+            },
+        });
+    }
+    //#endregion
+    //#region make report layout as default for all reports
+    makeReportDefaultLayout(reportUid) {
+        let request = {
+            reportTemplateUid: reportUid,
+        };
+        this.reportingService.makeReportLayoutAsDefaultLayout(request).subscribe({
+            next: (data) => {
+                console.log(data);
+                this.notificationService.success('shared_reporting_success_updated');
+            },
+            error: (error) => {
+                this.notificationService.warn('shared_reporting_error_occured');
+            },
+        });
+    }
+    //#end region
+    _viewDashboardt(uid) {
+        this.isloading = true;
+        let report = this.reports.find((r) => r.uid === uid);
+        if (!report) {
+            this.notificationService.error(this.errorMessageKey);
+            return;
+        }
+        let reportTemplateId = report.uid;
+        let tenantUid = this.identityManagerService.parseMyAuthToken()?.tenantUid;
+        let urlViewer = `${Segment.appBaseHref}/${this.dashboardModuleRoute}/${ManageReportingRoutes.dashboardViewer}?${queryParamNamesConst.reportTemplate}=${reportTemplateId}&${queryParamNamesConst.tenantUid}=${tenantUid}`;
+        console.log('>>> _viewDashboardt ~ urlViewer:', urlViewer);
+        window.open(urlViewer, '_blank');
+        this.notificationService.success('shared_reporting_redirected_to_print_report_successfully');
+        this.isloading = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ManageReportingComponent, deps: [{ token: i1.ReportingService }, { token: i1.IdentityManagerService }, { token: i1.TsiConfirmationService }, { token: i1.TsiNotificationService }, { token: i2.DynamicDialogRef }, { token: i2.DynamicDialogConfig }, { token: i1.TsiModalService }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ManageReportingComponent, selector: "app-manage-reporting", inputs: { otherFormName: "otherFormName", otherFormEndpoint: "otherFormEndpoint", formEndpointBody: "formEndpointBody", isFormEndpointPaged: "isFormEndpointPaged", filtersHtmlTemplate: "filtersHtmlTemplate", optionalEndpoints: "optionalEndpoints", customReportingMode: "customReportingMode" }, providers: [...appProviders], viewQueries: [{ propertyName: "fileUpload", first: true, predicate: ["fileUpload"], descendants: true }, { propertyName: "importFileToReportFileUpload", first: true, predicate: ["importFileToReportFileUpload"], descendants: true }], usesInheritance: true, ngImport: i0, template: "\r\n<div class=\"card\">\r\n  <div *busy=\"isloading\"></div>\r\n  <div class=\"grid\">\r\n    <div class=\"grid col-10\">\r\n      <div *ngIf=\"isFromForm; else notFromForm\">\r\n        <Tsi-Label class=\"col-2\" [labelValue]=\"'shared_reporting_form'\">\r\n        </Tsi-Label>\r\n        <p-dropdown class=\"col-10 tsi-component\" class=\"tsi-component\" styleClass=\"tsi-component\" appendTp=\"body\"\r\n          [options]=\"formNames\" [ngModel]=\"otherFormName\" optionLabel=\"value\" optionValue=\"key\" [filter]=\"true\"\r\n          filterBy=\"value\" [showClear]=\"true\" placeholder=\"{{'shared_reporting_select_form' | localize}}\"\r\n          [disabled]=\"true\">\r\n        </p-dropdown>\r\n      </div>\r\n\r\n      <ng-template #notFromForm>\r\n        <ng-container>\r\n          <Tsi-Label class=\"col-2\" [labelValue]=\"'shared_reporting_form'\">\r\n          </Tsi-Label>\r\n          <Tsi-Search-Combo class=\"col-10\" [(bind)]=\"otherFormName\" (bindChange)=\"onFormChange()\"\r\n            [listSourceUrl]=\"getFormNamesEndpoint\" [elementSourceUrl]=\"getFormNamesEndpoint \" [isFiltered]=\"true\"\r\n            id-field=\"key\" label-field=\"value\">\r\n          </Tsi-Search-Combo>\r\n        </ng-container>\r\n      </ng-template>\r\n    </div>\r\n  </div>\r\n\r\n  <p-toolbar styleClass=\"mb-4 gap-2\">\r\n    <ng-template pTemplate=\"left\">\r\n      <Tsi-Button [text]=\"'shared_reporting_add_report' | localize\" icon=\"p-button-icon p-button-icon-left pi pi-plus\"\r\n        styleClass=\"p-element p-button-success ml-2 mr-2 p-button p-component ng-star-inserted p-button-label\" (click)=\"onNewReport()\"></Tsi-Button>\r\n      <Tsi-Button [buttonType]=\"buttonType.Submit\" [text]=\"'shared_reporting_delete_report' | localize\" icon=\"p-button-icon p-button-icon-left pi pi-trash\"\r\n        styleClass=\"p-element p-button-danger p-button p-component ng-star-inserted p-button-label\" (click)=\"onDeleteSelectedReports()\"\r\n        [disabled]=\"!selectedReports || !selectedReports.length\"></Tsi-Button>\r\n    </ng-template>\r\n\r\n    <ng-template pTemplate=\"right\">\r\n      <p-fileUpload #fileUpload name=\"demo[]\" (onBeforeUpload)=\"onImportFile($event)\"\r\n        (onSelect)=\"onFileSelected($event)\" (onClear)=\"onClear($event)\" (onRemove)=\"onRemove($event)\" [multiple]=\"false\"\r\n        accept=\"application/json\" [maxFileSize]=\"10000000\" \r\n        [invalidFileSizeMessageSummary]=\"'shared_file_upload_invalid_file_size_message_summary' | localize\"\r\n        [invalidFileSizeMessageDetail]=\"'shared_file_upload_invalid_file_size_message_detail' | localize\"\r\n        [invalidFileTypeMessageSummary]=\"'shared_file_upload_invalid_file_type_message_summary' | localize\"\r\n        [invalidFileLimitMessageDetail]=\"'shared_file_upload_invalid_file_limit_message_detail' | localize\"\r\n        [invalidFileLimitMessageSummary]=\"'shared_file_upload_invalid_file_limit_message_summary' | localize\"\r\n        [invalidFileTypeMessageDetail]=\"'shared_file_upload_invalid_file_type_message_detail' | localize\"\r\n        [chooseIcon]=\"'pi pi-paperclip'\" cancelStyleClass=\"p-button-secondary\" uploadStyleClass=\"p-button-help\"\r\n        removeStyleClass=\"p-button-danger\" [chooseLabel]=\"'shared_reporting_choose_report_file' | localize\"\r\n        [uploadLabel]=\"'shared_reporting_import_report' | localize\"\r\n        [cancelLabel]=\"'shared_reporting_cancel_choose_report_file' | localize\">\r\n        <ng-template *ngIf=\"toUploadFileData\" pTemplate=\"fileupload-content\">\r\n        </ng-template>\r\n      </p-fileUpload>\r\n    </ng-template>\r\n  </p-toolbar>\r\n\r\n  <!-- <Tsi-Display-Grid [showHeader]=\"true\"\r\n    [header]=\"'shared_reporting_my_template'\"\r\n    [columns]=\"columns\" [gridData]=\"reports\" key=\"uid\"\r\n    (buttonColumnClicked)=\"handleButtonColumnClicked($event)\" [(selectedItems)]=\"selectedReports\"\r\n    [showFilters]=\"false\"\r\n    [paginator]=\"true\"\r\n    [globalFilterFields]=\"globalFilterFields\">\r\n  </Tsi-Display-Grid> -->\r\n\r\n\r\n  <!--<div style=\"text-align:left\"> <p-button icon=\"pi pi-refresh\"  [pTooltip]=\"'shared_reporting_refresh' | localize\" [tooltipPosition]=\"tooltipPosition.Top\"  label=\"Reload\" severity=\"help\" (click)=\"onRefresh()\" /> </div>\r\n  <p-button icon=\"pi pi-refresh\" class=\"p-button-rounded\" styleClass=\"p-button-text\" />\r\n-->\r\n  \r\n  <Tsi-Button styleClass=\"p-element p-button-text p-button-raised p-button-rounded mb-3 ml-3\"  \r\n    [tooltipText]=\"'shared_reporting_refresh'\" [tooltipPosition]=\"tooltipPosition.Top\"\r\n    icon=\"pi pi-refresh\" (click)=\"onRefresh()\"></Tsi-Button>\r\n\r\n  <tsi-view-grid \r\n    [header]=\"'shared_reporting_my_template'\"\r\n    [columns]=\"columns\" [gridData]=\"reports\" key=\"uid\"\r\n    (buttonColumnClicked)=\"handleButtonColumnClicked($event)\" [(selectedItems)]=\"selectedReports\"\r\n    [getDataFromApi]=\"false\"\r\n    [formName]=\"'my-report-templates'\"\r\n    >\r\n  </tsi-view-grid>\r\n  <br/>\r\n   <!-- Default Template -->\r\n   <!-- <Tsi-Display-Grid \r\n   [showHeader]=\"true\" \r\n   [header]=\"'shared_reporting_BuiltIn_template'\"\r\n   [showSummaryFooter]=\"false\" \r\n   [paginator]=\"false\" \r\n   [showFilters]=\"false\" \r\n   [columns]=\"defaultTemplateColumns\" \r\n   [gridData]=\"defaultReportTemplateData\" \r\n   (buttonColumnClicked)=\"handleButtonColumnClicked($event)\"\r\n   [paginator]=\"true\"\r\n   key=\"name\">\r\n  </Tsi-Display-Grid> -->\r\n\r\n  \r\n  <tsi-view-grid\r\n   [header]=\"'shared_reporting_BuiltIn_template'\"\r\n   [columns]=\"defaultTemplateColumns\" \r\n   [gridData]=\"defaultReportTemplateData\" \r\n   (buttonColumnClicked)=\"handleButtonColumnClicked($event)\"\r\n   [getDataFromApi]=\"false\"\r\n   [formName]=\"'default-my-report-templates'\"\r\n   key=\"name\">\r\n  </tsi-view-grid>\r\n\r\n\r\n\r\n\r\n  \r\n\r\n  <!-- dialog to import file to report -->\r\n  <p-dialog header=\"{{'shared_reporting_select_file_to_import_into_report' | localize}}\" [(visible)]=\"isUpdateReportFromFileDialogVisible\" [style]=\"{width: '50vw'}\">\r\n    <!-- <Tsi-Modal-Header (onCloseClick)=\"onImportFileToReportModalCancelClick()\" [inputTitle]=\"'shared_reporting_select_file_to_import_into_report'\"></Tsi-Modal-Header> -->\r\n\r\n    <ng-template pTemplate=\"body\">\r\n      <p-fileUpload #importFileToReportFileUpload name=\"importFileToReport\" (onBeforeUpload)=\"onImportFileToReport_ImportFile($event)\"\r\n        (onSelect)=\"onImportFileToReport_FileSelected($event)\" (onClear)=\"onImportFileToReport_Clear($event)\" (onRemove)=\"onImportFileToReport_Remove($event)\" [multiple]=\"false\"\r\n        accept=\"application/json\" [maxFileSize]=\"10000000\"\r\n        [invalidFileSizeMessageSummary]=\"'shared_file_upload_invalid_file_size_message_summary' | localize\"\r\n        [invalidFileSizeMessageDetail]=\"'shared_file_upload_invalid_file_size_message_detail' | localize\"\r\n        [invalidFileTypeMessageSummary]=\"'shared_file_upload_invalid_file_type_message_summary' | localize\"\r\n        [invalidFileLimitMessageDetail]=\"'shared_file_upload_invalid_file_limit_message_detail' | localize\"\r\n        [invalidFileLimitMessageSummary]=\"'shared_file_upload_invalid_file_limit_message_summary' | localize\"\r\n        [invalidFileTypeMessageDetail]=\"'shared_file_upload_invalid_file_type_message_detail' | localize\"\r\n        [chooseIcon]=\"'pi pi-paperclip'\" cancelStyleClass=\"p-button-secondary\" uploadStyleClass=\"p-button-help\"\r\n        removeStyleClass=\"p-button-danger\" [chooseLabel]=\"'shared_reporting_choose_report_file' | localize\"\r\n        [uploadLabel]=\"'shared_reporting_import_report' | localize\"\r\n        [cancelLabel]=\"'shared_reporting_cancel_choose_report_file' | localize\">\r\n        <ng-template *ngIf=\"toUploadToUpdateReportFileData\" pTemplate=\"fileupload-content\">\r\n        </ng-template>\r\n      </p-fileUpload>\r\n    </ng-template>\r\n\r\n    <!-- <Tsi-Modal-Footer (onCancelClick)=\"onImportFileToReportModalCancelClick()\"\r\n    (onSaveClick)=\"onImportFileToReportModalSaveClick()\"\r\n    [saveDisabled]=\"!toUploadToUpdateReportFileData\"></Tsi-Modal-Footer> -->\r\n\r\n</p-dialog>\r\n</div>\r\n", styles: [".p-button.p-button-icon-only.p-button-rounded{height:2rem!important}::ng-deep .p-fileupload-choose input{display:none!important}\n"], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i6.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "component", type: i7.Toolbar, selector: "p-toolbar", inputs: ["style", "styleClass", "ariaLabelledBy"] }, { kind: "component", type: i8.Dialog, selector: "p-dialog", inputs: ["header", "draggable", "resizable", "positionLeft", "positionTop", "contentStyle", "contentStyleClass", "modal", "closeOnEscape", "dismissableMask", "rtl", "closable", "responsive", "appendTo", "breakpoints", "styleClass", "maskStyleClass", "maskStyle", "showHeader", "breakpoint", "blockScroll", "autoZIndex", "baseZIndex", "minX", "minY", "focusOnShow", "maximizable", "keepInViewport", "focusTrap", "transitionOptions", "closeIcon", "closeAriaLabel", "closeTabindex", "minimizeIcon", "maximizeIcon", "visible", "style", "position"], outputs: ["onShow", "onHide", "visibleChange", "onResizeInit", "onResizeEnd", "onDragEnd", "onMaximize"] }, { kind: "component", type: i9.Dropdown, selector: "p-dropdown", inputs: ["id", "scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "loadingIcon", "filterPlaceholder", "filterLocale", "variant", "inputId", "dataKey", "filterBy", "filterFields", "autofocus", "resetFilterOnHide", "checkmark", "dropdownIcon", "loading", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "ariaLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "focusOnHover", "selectOnFocus", "autoOptionFocus", "autofocusFilter", "autoShowPanelOnPrintableCharacterKeyDown", "disabled", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "filterValue", "options"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear", "onLazyLoad"] }, { kind: "component", type: i10.FileUpload, selector: "p-fileUpload", inputs: ["name", "url", "method", "multiple", "accept", "disabled", "auto", "withCredentials", "maxFileSize", "invalidFileSizeMessageSummary", "invalidFileSizeMessageDetail", "invalidFileTypeMessageSummary", "invalidFileTypeMessageDetail", "invalidFileLimitMessageDetail", "invalidFileLimitMessageSummary", "style", "styleClass", "previewWidth", "chooseLabel", "uploadLabel", "cancelLabel", "chooseIcon", "uploadIcon", "cancelIcon", "showUploadButton", "showCancelButton", "mode", "headers", "customUpload", "fileLimit", "uploadStyleClass", "cancelStyleClass", "removeStyleClass", "chooseStyleClass", "files"], outputs: ["onBeforeUpload", "onSend", "onUpload", "onError", "onClear", "onRemove", "onSelect", "onProgress", "uploadHandler", "onImageError", "onRemoveUploadedFile"] }, { kind: "component", type: i11.TsiSearchComboComponent, selector: "Tsi-Search-Combo", inputs: ["elementSourceUrl", "listSourceUrl", "id-field", "label-field", "multiple", "sort", "showClear", "reloadDataSource", "isFiltered", "selectedLabel", "maxWidth", "businessClass", "currentRowItem", "datasource", "bind", "showSearchButton", "showAddButton", "showConsultButton", "showUpdateButton"], outputs: ["bindChange", "datasource-loaded", "init", "isLoaded", "selectedLabelChange", "onClick", "onSearchButtonClick"] }, { kind: "component", type: i12.TsiLabelComponent, selector: "Tsi-Label", inputs: ["labelValue", "styleClass", "infoText"] }, { kind: "component", type: i13.TsiViewGridComponent, selector: "tsi-view-grid", inputs: ["columns", "gridConfiguration", "viewComponent", "crudService", "header", "modalSize", "showConsultButton", "showSearchField", "searchFields", "formEndpoint", "formName", "id", "showImportExportButton", "getDataFromApi", "gridData", "isSearchButtonDisabled", "selectKeyOnly", "selectionMode", "selectedItems", "key", "showGlobalSearch", "showExportButton", "showCalenderView", "calenderSchema", "showHeaderFilters", "showFilterButton", "selectAll", "checkedByField", "searchOnInit"], outputs: ["summariesChange", "selectedItemsChange", "buttonColumnClicked", "searchFieldsValueChanged", "getAllPagedResultChanged"] }, { kind: "component", type: i14.TsiButtonComponent, selector: "Tsi-Button", inputs: ["disabled", "text", "style", "tooltipText", "tooltipPosition", "buttonType", "icon", "styleClass", "iconSrc", "id", "iconWidth", "iconClass"], outputs: ["onClick", "rightClick"] }, { kind: "directive", type: i15.BusyDirective, selector: "[busy]", inputs: ["busy"] }, { kind: "pipe", type: i16.LocalizePipe, name: "localize" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ManageReportingComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-manage-reporting', providers: [...appProviders], template: "\r\n<div class=\"card\">\r\n  <div *busy=\"isloading\"></div>\r\n  <div class=\"grid\">\r\n    <div class=\"grid col-10\">\r\n      <div *ngIf=\"isFromForm; else notFromForm\">\r\n        <Tsi-Label class=\"col-2\" [labelValue]=\"'shared_reporting_form'\">\r\n        </Tsi-Label>\r\n        <p-dropdown class=\"col-10 tsi-component\" class=\"tsi-component\" styleClass=\"tsi-component\" appendTp=\"body\"\r\n          [options]=\"formNames\" [ngModel]=\"otherFormName\" optionLabel=\"value\" optionValue=\"key\" [filter]=\"true\"\r\n          filterBy=\"value\" [showClear]=\"true\" placeholder=\"{{'shared_reporting_select_form' | localize}}\"\r\n          [disabled]=\"true\">\r\n        </p-dropdown>\r\n      </div>\r\n\r\n      <ng-template #notFromForm>\r\n        <ng-container>\r\n          <Tsi-Label class=\"col-2\" [labelValue]=\"'shared_reporting_form'\">\r\n          </Tsi-Label>\r\n          <Tsi-Search-Combo class=\"col-10\" [(bind)]=\"otherFormName\" (bindChange)=\"onFormChange()\"\r\n            [listSourceUrl]=\"getFormNamesEndpoint\" [elementSourceUrl]=\"getFormNamesEndpoint \" [isFiltered]=\"true\"\r\n            id-field=\"key\" label-field=\"value\">\r\n          </Tsi-Search-Combo>\r\n        </ng-container>\r\n      </ng-template>\r\n    </div>\r\n  </div>\r\n\r\n  <p-toolbar styleClass=\"mb-4 gap-2\">\r\n    <ng-template pTemplate=\"left\">\r\n      <Tsi-Button [text]=\"'shared_reporting_add_report' | localize\" icon=\"p-button-icon p-button-icon-left pi pi-plus\"\r\n        styleClass=\"p-element p-button-success ml-2 mr-2 p-button p-component ng-star-inserted p-button-label\" (click)=\"onNewReport()\"></Tsi-Button>\r\n      <Tsi-Button [buttonType]=\"buttonType.Submit\" [text]=\"'shared_reporting_delete_report' | localize\" icon=\"p-button-icon p-button-icon-left pi pi-trash\"\r\n        styleClass=\"p-element p-button-danger p-button p-component ng-star-inserted p-button-label\" (click)=\"onDeleteSelectedReports()\"\r\n        [disabled]=\"!selectedReports || !selectedReports.length\"></Tsi-Button>\r\n    </ng-template>\r\n\r\n    <ng-template pTemplate=\"right\">\r\n      <p-fileUpload #fileUpload name=\"demo[]\" (onBeforeUpload)=\"onImportFile($event)\"\r\n        (onSelect)=\"onFileSelected($event)\" (onClear)=\"onClear($event)\" (onRemove)=\"onRemove($event)\" [multiple]=\"false\"\r\n        accept=\"application/json\" [maxFileSize]=\"10000000\" \r\n        [invalidFileSizeMessageSummary]=\"'shared_file_upload_invalid_file_size_message_summary' | localize\"\r\n        [invalidFileSizeMessageDetail]=\"'shared_file_upload_invalid_file_size_message_detail' | localize\"\r\n        [invalidFileTypeMessageSummary]=\"'shared_file_upload_invalid_file_type_message_summary' | localize\"\r\n        [invalidFileLimitMessageDetail]=\"'shared_file_upload_invalid_file_limit_message_detail' | localize\"\r\n        [invalidFileLimitMessageSummary]=\"'shared_file_upload_invalid_file_limit_message_summary' | localize\"\r\n        [invalidFileTypeMessageDetail]=\"'shared_file_upload_invalid_file_type_message_detail' | localize\"\r\n        [chooseIcon]=\"'pi pi-paperclip'\" cancelStyleClass=\"p-button-secondary\" uploadStyleClass=\"p-button-help\"\r\n        removeStyleClass=\"p-button-danger\" [chooseLabel]=\"'shared_reporting_choose_report_file' | localize\"\r\n        [uploadLabel]=\"'shared_reporting_import_report' | localize\"\r\n        [cancelLabel]=\"'shared_reporting_cancel_choose_report_file' | localize\">\r\n        <ng-template *ngIf=\"toUploadFileData\" pTemplate=\"fileupload-content\">\r\n        </ng-template>\r\n      </p-fileUpload>\r\n    </ng-template>\r\n  </p-toolbar>\r\n\r\n  <!-- <Tsi-Display-Grid [showHeader]=\"true\"\r\n    [header]=\"'shared_reporting_my_template'\"\r\n    [columns]=\"columns\" [gridData]=\"reports\" key=\"uid\"\r\n    (buttonColumnClicked)=\"handleButtonColumnClicked($event)\" [(selectedItems)]=\"selectedReports\"\r\n    [showFilters]=\"false\"\r\n    [paginator]=\"true\"\r\n    [globalFilterFields]=\"globalFilterFields\">\r\n  </Tsi-Display-Grid> -->\r\n\r\n\r\n  <!--<div style=\"text-align:left\"> <p-button icon=\"pi pi-refresh\"  [pTooltip]=\"'shared_reporting_refresh' | localize\" [tooltipPosition]=\"tooltipPosition.Top\"  label=\"Reload\" severity=\"help\" (click)=\"onRefresh()\" /> </div>\r\n  <p-button icon=\"pi pi-refresh\" class=\"p-button-rounded\" styleClass=\"p-button-text\" />\r\n-->\r\n  \r\n  <Tsi-Button styleClass=\"p-element p-button-text p-button-raised p-button-rounded mb-3 ml-3\"  \r\n    [tooltipText]=\"'shared_reporting_refresh'\" [tooltipPosition]=\"tooltipPosition.Top\"\r\n    icon=\"pi pi-refresh\" (click)=\"onRefresh()\"></Tsi-Button>\r\n\r\n  <tsi-view-grid \r\n    [header]=\"'shared_reporting_my_template'\"\r\n    [columns]=\"columns\" [gridData]=\"reports\" key=\"uid\"\r\n    (buttonColumnClicked)=\"handleButtonColumnClicked($event)\" [(selectedItems)]=\"selectedReports\"\r\n    [getDataFromApi]=\"false\"\r\n    [formName]=\"'my-report-templates'\"\r\n    >\r\n  </tsi-view-grid>\r\n  <br/>\r\n   <!-- Default Template -->\r\n   <!-- <Tsi-Display-Grid \r\n   [showHeader]=\"true\" \r\n   [header]=\"'shared_reporting_BuiltIn_template'\"\r\n   [showSummaryFooter]=\"false\" \r\n   [paginator]=\"false\" \r\n   [showFilters]=\"false\" \r\n   [columns]=\"defaultTemplateColumns\" \r\n   [gridData]=\"defaultReportTemplateData\" \r\n   (buttonColumnClicked)=\"handleButtonColumnClicked($event)\"\r\n   [paginator]=\"true\"\r\n   key=\"name\">\r\n  </Tsi-Display-Grid> -->\r\n\r\n  \r\n  <tsi-view-grid\r\n   [header]=\"'shared_reporting_BuiltIn_template'\"\r\n   [columns]=\"defaultTemplateColumns\" \r\n   [gridData]=\"defaultReportTemplateData\" \r\n   (buttonColumnClicked)=\"handleButtonColumnClicked($event)\"\r\n   [getDataFromApi]=\"false\"\r\n   [formName]=\"'default-my-report-templates'\"\r\n   key=\"name\">\r\n  </tsi-view-grid>\r\n\r\n\r\n\r\n\r\n  \r\n\r\n  <!-- dialog to import file to report -->\r\n  <p-dialog header=\"{{'shared_reporting_select_file_to_import_into_report' | localize}}\" [(visible)]=\"isUpdateReportFromFileDialogVisible\" [style]=\"{width: '50vw'}\">\r\n    <!-- <Tsi-Modal-Header (onCloseClick)=\"onImportFileToReportModalCancelClick()\" [inputTitle]=\"'shared_reporting_select_file_to_import_into_report'\"></Tsi-Modal-Header> -->\r\n\r\n    <ng-template pTemplate=\"body\">\r\n      <p-fileUpload #importFileToReportFileUpload name=\"importFileToReport\" (onBeforeUpload)=\"onImportFileToReport_ImportFile($event)\"\r\n        (onSelect)=\"onImportFileToReport_FileSelected($event)\" (onClear)=\"onImportFileToReport_Clear($event)\" (onRemove)=\"onImportFileToReport_Remove($event)\" [multiple]=\"false\"\r\n        accept=\"application/json\" [maxFileSize]=\"10000000\"\r\n        [invalidFileSizeMessageSummary]=\"'shared_file_upload_invalid_file_size_message_summary' | localize\"\r\n        [invalidFileSizeMessageDetail]=\"'shared_file_upload_invalid_file_size_message_detail' | localize\"\r\n        [invalidFileTypeMessageSummary]=\"'shared_file_upload_invalid_file_type_message_summary' | localize\"\r\n        [invalidFileLimitMessageDetail]=\"'shared_file_upload_invalid_file_limit_message_detail' | localize\"\r\n        [invalidFileLimitMessageSummary]=\"'shared_file_upload_invalid_file_limit_message_summary' | localize\"\r\n        [invalidFileTypeMessageDetail]=\"'shared_file_upload_invalid_file_type_message_detail' | localize\"\r\n        [chooseIcon]=\"'pi pi-paperclip'\" cancelStyleClass=\"p-button-secondary\" uploadStyleClass=\"p-button-help\"\r\n        removeStyleClass=\"p-button-danger\" [chooseLabel]=\"'shared_reporting_choose_report_file' | localize\"\r\n        [uploadLabel]=\"'shared_reporting_import_report' | localize\"\r\n        [cancelLabel]=\"'shared_reporting_cancel_choose_report_file' | localize\">\r\n        <ng-template *ngIf=\"toUploadToUpdateReportFileData\" pTemplate=\"fileupload-content\">\r\n        </ng-template>\r\n      </p-fileUpload>\r\n    </ng-template>\r\n\r\n    <!-- <Tsi-Modal-Footer (onCancelClick)=\"onImportFileToReportModalCancelClick()\"\r\n    (onSaveClick)=\"onImportFileToReportModalSaveClick()\"\r\n    [saveDisabled]=\"!toUploadToUpdateReportFileData\"></Tsi-Modal-Footer> -->\r\n\r\n</p-dialog>\r\n</div>\r\n", styles: [".p-button.p-button-icon-only.p-button-rounded{height:2rem!important}::ng-deep .p-fileupload-choose input{display:none!important}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ReportingService }, { type: i1.IdentityManagerService }, { type: i1.TsiConfirmationService }, { type: i1.TsiNotificationService }, { type: i2.DynamicDialogRef }, { type: i2.DynamicDialogConfig }, { type: i1.TsiModalService }, { type: i3.Router }], propDecorators: { fileUpload: [{
+                type: ViewChild,
+                args: ['fileUpload']
+            }], importFileToReportFileUpload: [{
+                type: ViewChild,
+                args: ['importFileToReportFileUpload']
+            }], otherFormName: [{
+                type: Input
+            }], otherFormEndpoint: [{
+                type: Input
+            }], formEndpointBody: [{
+                type: Input
+            }], isFormEndpointPaged: [{
+                type: Input
+            }], filtersHtmlTemplate: [{
+                type: Input
+            }], optionalEndpoints: [{
+                type: Input
+            }], customReportingMode: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manage-reporting.component.js","sourceRoot":"","sources":["../../../../../../projects/tsi-shared-ui/src/lib/tsi-components/manage-reporting/manage-reporting.component.ts","../../../../../../projects/tsi-shared-ui/src/lib/tsi-components/manage-reporting/manage-reporting.component.html"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from '@angular/common/http';\r\nimport { Component, Input, OnDestroy, OnInit, ViewChild } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\nimport { FileUpload } from 'primeng/fileupload';\r\nimport { TooltipPosition } from '../../enums/tooltipPosition.enum';\r\nimport { ButtonType } from '../../enums/button-type.enum';\r\nimport { AddReportPopupComponent } from './add-report-popup/add-report-popup.component';\r\nimport { firstValueFrom } from 'rxjs';\r\nimport { LocalizationKeys } from '../../consts/localization-key';\r\nimport { Segment } from '../../end-points';\r\nimport { GridSelectionMode, HttpMethodType, TsiReportType, DisplayTypes, CSSUnits, ModalSizeEnum, Modes } from '../../enums';\r\nimport { GridColumn, CSSSizeProperty, ButtonClickResult } from '../../interfaces';\r\nimport { ReportTemplateResponse, JsonDataConnection, KeyValuePair, OptionalEndpoints, ReportToEditTemplatePayload, ReportToPrint, ReportToTemplate, ReportToEditTemplate } from '../../models';\r\nimport { AppRoutes } from '../../routes/app.routes';\r\nimport { ReportingService, IdentityManagerService, TsiConfirmationService, TsiNotificationService, TsiModalService } from '../../services';\r\nimport { TsiFormComponentBaseComponent } from '../../tsi-base/components/tsi-form-base/tsi-form-base.component';\r\nimport { ReportingEndpoints } from '../../end-points/reporting-endpoints';\r\nimport { queryParamNamesConst } from '../../consts/queryParamNames.const';\r\nimport { ManageReportingRoutes } from '../../routes/manage-reporting.routes';\r\nimport { appProviders } from '../../consts/app-providers';\r\nimport { DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';\r\n\r\n@Component({\r\n  selector: 'app-manage-reporting',\r\n  templateUrl: './manage-reporting.component.html',\r\n  styleUrls: ['./manage-reporting.component.scss'],\r\n  providers: [...appProviders],\r\n})\r\nexport class ManageReportingComponent\r\n  extends TsiFormComponentBaseComponent\r\n  implements OnInit, OnDestroy {\r\n  //#region properties\r\n\r\n  readonly EDITION_PERSONNALISE = 'app-edition-personnalise';\r\n  reports: ReportTemplateResponse[] = [];\r\n  jsonDataConnection: JsonDataConnection | undefined;\r\n  jsonDataConnectionId: number | undefined;\r\n  reportToPrintId: number | undefined;\r\n  toUploadFileData: any = undefined;\r\n  columns: GridColumn[] = [];\r\n  isFromForm: boolean = false;\r\n  formNames: KeyValuePair<string, string>[] = [];\r\n  selectedReports: number[] = [];\r\n  selectionMode = GridSelectionMode.Multiple;\r\n  getFormNamesEndpoint: string = ReportingEndpoints.getAvailableFormNames();\r\n  globalFilterFields = ['name'];\r\n  refreshJobTimeOut: any;\r\n  previousFormName: string = '';\r\n  isUpdateReportFromFileDialogVisible: boolean = false;\r\n  toUploadToUpdateReportFileData: any = undefined;\r\n  selectedReportToUpdateFromFile: number | undefined;\r\n  defaultReportTemplateData: string[] = [];\r\n  defaultTemplateColumns: GridColumn[] = [];\r\n  tooltipPosition = TooltipPosition;\r\n  private _dialogRef?: DynamicDialogRef;\r\n  isEditionPersonnalise: boolean = false;\r\n  entityId?: string;\r\n  reportDiscriminator?: any;\r\n  httpMethodType?: HttpMethodType\r\n  requestData?: any\r\n\r\n  private static readonly reportTypeLabels: Record<string, string> = {\r\n    [TsiReportType.Dashboard]: 'Dashboard',\r\n    [TsiReportType.List]: 'End user',\r\n    [TsiReportType.RTF]: 'RTF',\r\n  };\r\n\r\n  private _isReportForFiche: boolean = false;\r\n\r\n  get isReportForFiche(): boolean {\r\n    return !this.otherFormEndpoint?.includes('getallpaged') && !this.requestData;\r\n  }\r\n\r\n  @ViewChild('fileUpload') fileUpload?: FileUpload;\r\n  @ViewChild('importFileToReportFileUpload')\r\n  importFileToReportFileUpload?: FileUpload;\r\n  private readonly errorMessageKey: string = 'shared_reporting_error_occured';\r\n\r\n  private readonly dashboardModuleRoute = `${AppRoutes.app}/${AppRoutes.dashboard}`;\r\n  //#endregion\r\n  buttonType = ButtonType;\r\n  // parametre: ParametresApplicationPaie = new ParametresApplicationPaie();\r\n  //#region Input properties\r\n  @Input() otherFormName: string | undefined; //formIdentifier\r\n  @Input() otherFormEndpoint: string | undefined; //= `${GestionCommercialeSegments.factureVente}/165ec5fd-4d34-4546-ae15-0044e708b9d9`;\r\n  @Input() formEndpointBody: string | undefined; //formIdentifier\r\n  @Input() isFormEndpointPaged: boolean = false;\r\n  @Input() filtersHtmlTemplate: string | undefined;\r\n  @Input() optionalEndpoints?: OptionalEndpoints;\r\n  @Input() customReportingMode?: boolean\r\n  //#endregion\r\n\r\n  //#region Output properties\r\n  //@Output() hide: EventEmitter<void> = new EventEmitter<void>();\r\n  //#endregion\r\n\r\n  //#region ctor\r\n  constructor(\r\n   // public _parametresApplicationPaieService: ParametresApplicationPaieService,\r\n    private reportingService: ReportingService,\r\n    private identityManagerService: IdentityManagerService,\r\n    private confirmationService: TsiConfirmationService,\r\n    private notificationService: TsiNotificationService,\r\n    public override ref: DynamicDialogRef,\r\n    public override config: DynamicDialogConfig,\r\n    private _tsiModalService: TsiModalService,\r\n    private router: Router,\r\n  ) {\r\n    super(ref, config);\r\n\r\n    //init columns\r\n    this.columns = [\r\n      {\r\n        field: 'name',\r\n        header: 'shared_reporting_report_name',\r\n      },\r\n      {\r\n        field: 'reportTypeName',\r\n        header: 'shared_reporting_report_type',\r\n      },\r\n      {\r\n        field: 'isDefault',\r\n        header: 'shared_reporting_report_isdefault',\r\n        type: DisplayTypes.CHECKBOX_DISPLAY,\r\n        width: new CSSSizeProperty(10, CSSUnits.PRECENT),\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'send',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-send',\r\n        styleClass: 'p-button-text p-button-success',\r\n        toolTipText: 'shared_send_report_by_email',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'edit',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-file-edit',\r\n        styleClass: 'p-button-text p-button-success',\r\n        toolTipText: 'shared_reporting_edit',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'view',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-eye',\r\n        styleClass: 'p-button-text p-button-info',\r\n        toolTipText: 'shared_reporting_view',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'export',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-file-export',\r\n        styleClass: 'p-button-text p-button-help',\r\n        toolTipText: 'shared_reporting_export',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'import',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-paperclip',\r\n        styleClass: 'p-button-text p-button-warning',\r\n        toolTipText: 'shared_reporting_import',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'default',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-bookmark-fill',\r\n        styleClass: 'p-button-text',\r\n        toolTipText: 'shared_reporting_set_default',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'delete',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-trash',\r\n        styleClass: 'p-button-text p-button-danger',\r\n        toolTipText: 'shared_reporting_delete_report',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'Add_To_BuiltIn_Templates',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-arrow-circle-down',\r\n        styleClass: 'p-button-text p-button-help',\r\n        toolTipText: 'shared_reporting_export_dev_report',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'Make_default_report_layout',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-bookmark-fill',\r\n        styleClass: 'p-button-text p-button-danger',\r\n        toolTipText: 'shared_reporting_make_default_report_layout',\r\n      },\r\n    ];\r\n    this.defaultTemplateColumns = [\r\n      {\r\n        field: 'name',\r\n        header: 'shared_reporting_report_name',\r\n      },\r\n      {\r\n        field: 'reportTypeName',\r\n        header: 'shared_reporting_report_type',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'deleteDefaultReportFile',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-trash',\r\n        styleClass: 'p-button-text p-button-danger',\r\n        toolTipText: 'shared_reporting_delete_default_report',\r\n      },\r\n      {\r\n        header: '',\r\n        field: 'Add_From_BuiltIn_Templates',\r\n        isButton: true,\r\n        buttonIcon: 'pi pi-arrow-circle-up',\r\n        styleClass: 'p-button-text p-button-primary',\r\n        toolTipText: 'shared_reporting_add_to_my_list_report',\r\n      },\r\n    ];\r\n  }\r\n  //#endregion\r\n\r\n  checkIfIsDevMode() {\r\n    if (Segment.production) {\r\n      let buttonAdBuiltinTemplatesIndex = this.columns.findIndex(\r\n        (col: GridColumn) => {\r\n          return col.field == 'Add_To_BuiltIn_Templates';\r\n        }\r\n      );\r\n      if (buttonAdBuiltinTemplatesIndex != -1) {\r\n        this.columns.splice(buttonAdBuiltinTemplatesIndex, 1);\r\n      }\r\n\r\n      let buttonDeleteDefaultReportFileIndex =\r\n        this.defaultTemplateColumns.findIndex((col: GridColumn) => {\r\n          return col.field == 'deleteDefaultReportFile';\r\n        });\r\n\r\n      if (buttonDeleteDefaultReportFileIndex != -1) {\r\n        this.defaultTemplateColumns.splice(\r\n          buttonDeleteDefaultReportFileIndex,\r\n          1\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  //handle Lifecycle Hooks\r\n  override async ngOnInit() {\r\n    this.isEditionPersonnalise = this.router.url.includes('administration');\r\n    this.checkIfIsDevMode();\r\n    super.ngOnInit();\r\n    // if (this.otherFormName ) {\r\n    this.isFromForm = true;\r\n    this.columns.splice(3, 0, {\r\n      header: '',\r\n      field: 'print',\r\n      isButton: true,\r\n      buttonIcon: 'pi pi-print',\r\n      styleClass: 'p-button-text p-button-secondary',\r\n      toolTipText: 'shared_reporting_report_print',\r\n    });\r\n    if (this.otherFormName && this.otherFormName != 'app-manage-reporting') {\r\n      this.formNames = [{ key: this.otherFormName, value: this.otherFormName }];\r\n    }\r\n    this.entityId = this.config.data?.id;\r\n    this.customReportingMode = this.config?.data?.customReportingMode\r\n    this.httpMethodType = this.config?.data?.httpMethodType\r\n    await this._refreshReports(true);\r\n  }\r\n\r\n  override ngOnDestroy(): void {\r\n    super.ngOnDestroy();\r\n\r\n    if (this.refreshJobTimeOut) {\r\n      clearTimeout(this.refreshJobTimeOut);\r\n    }\r\n  }\r\n  //#endregion\r\n\r\n  //#region handle events\r\n  async onRefresh() {\r\n    await this._refreshReports(true);\r\n  }\r\n\r\n  onPrintDefault(event: any): void {\r\n    if (this.otherFormName) {\r\n      this.reportingService.getDefaultReport(this.otherFormName).subscribe({\r\n        next: (data) => {\r\n          // let defaultReportId: string = data;\r\n          this._viewReport(data.uid);\r\n        },\r\n        error: (error: any) => { },\r\n      });\r\n    }\r\n  }\r\n\r\n  onFileSelected(event: any): void {\r\n    const file: File = event.currentFiles[0];\r\n    this.toUploadFileData = file;\r\n  }\r\n\r\n  onImportFile(event: any): void {\r\n    this.reportingService.uploadReportFile(this.toUploadFileData, this.reportDiscriminator).subscribe({\r\n      next: async (response) => {\r\n        await this._refreshReports();\r\n        this.notificationService.success(\r\n          'shared_reporting_report_uploaded_successfully'\r\n        );\r\n        this.fileUpload?.clear();\r\n      },\r\n      error: () => {\r\n        this.notificationService.error(this.errorMessageKey);\r\n      },\r\n    });\r\n  }\r\n\r\n  //cancel button click\r\n  onClear(event: any): void {\r\n    this.toUploadFileData = undefined;\r\n  }\r\n\r\n  //cancel button click\r\n  onRemove(event: any): void {\r\n    this.toUploadFileData = undefined;\r\n  }\r\n\r\n  handleButtonColumnClicked(event: ButtonClickResult): void {\r\n    switch (event.field) {\r\n      case 'send': {\r\n        console.log('send');\r\n        this._sendReport(event.key);\r\n        break;\r\n      }\r\n      case 'edit': {\r\n        console.log('edit');\r\n        this._editReport(event.key);\r\n        break;\r\n      }\r\n      case 'view': {\r\n        console.log('view');\r\n        this._viewDashboardt(event.key);\r\n        break;\r\n      }\r\n      case 'delete': {\r\n        console.log('delete');\r\n        this._deleteReport(event.key);\r\n        break;\r\n      }\r\n      case 'print': {\r\n        console.log('print');\r\n        this._viewReport(event.key);\r\n        break;\r\n      }\r\n      case 'export': {\r\n        console.log('export');\r\n        this._exportReport(event.key);\r\n        break;\r\n      }\r\n      case 'default': {\r\n        console.log('default');\r\n        this._setDefaultReport(event.key);\r\n        break;\r\n      }\r\n      case 'import': {\r\n        console.log('import');\r\n        this._importToReport(event.key);\r\n        break;\r\n      }\r\n      case 'Add_From_BuiltIn_Templates': {\r\n        console.log('Add_From_BuiltIn_Templates');\r\n        this._addFromBuiltInTemplates(event.key);\r\n        break;\r\n      }\r\n      case 'Add_To_BuiltIn_Templates': {\r\n        console.log('Add_To_BuiltIn_Templates');\r\n        this._addToBuiltInTemplates(event.key);\r\n        break;\r\n      }\r\n      case 'preview': {\r\n        console.log('preview');\r\n        this.previewBuiltInReportTemplate(event.key);\r\n        break;\r\n      }\r\n      case 'Make_default_report_layout': {\r\n        this.makeReportDefaultLayout(event.key);\r\n        break;\r\n      }\r\n      case 'deleteDefaultReportFile': {\r\n        this.deleteDefaultReportFile(event.key);\r\n        break;\r\n      }\r\n      default:\r\n        break;\r\n    }\r\n  }\r\n\r\n  deleteDefaultReportFile(fileName: any) {\r\n    this.confirmationService.confirm(\r\n      LocalizationKeys.confirmDelete,\r\n      undefined,\r\n      (result: boolean) => {\r\n        if (result && result == true) {\r\n          this.isloading = true;\r\n          let formName = this.otherFormName ?? this.EDITION_PERSONNALISE;\r\n          this.reportingService\r\n            .deleteDefaultReportTemplateFile(formName, fileName)\r\n            .subscribe({\r\n              next: async () => {\r\n                await this._refreshReports(true);\r\n                this.notificationService.success(\r\n                  LocalizationKeys.deletedSuccessfully\r\n                );\r\n                this.isloading = false;\r\n              },\r\n              error: () => {\r\n                this.notificationService.error(this.errorMessageKey);\r\n                this.isloading = false;\r\n              },\r\n            });\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  onDeleteSelectedReports(): void {\r\n    this.confirmationService.confirm(\r\n      LocalizationKeys.confirmDelete,\r\n      undefined,\r\n      (result: boolean) => {\r\n        if (\r\n          result &&\r\n          this.selectedReports != null &&\r\n          this.selectedReports != undefined\r\n        ) {\r\n          this.isloading = true;\r\n          this.reportingService\r\n            .deleteMultipleReports(this.selectedReports)\r\n            .subscribe({\r\n              next: async () => {\r\n                await this._refreshReports();\r\n                this.notificationService.success(\r\n                  LocalizationKeys.deletedSuccessfully\r\n                );\r\n                this.isloading = false;\r\n              },\r\n              error: (error: any) => {\r\n                this.notificationService.error(this.errorMessageKey);\r\n                this.isloading = false;\r\n              },\r\n            });\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  onNewReport(): void {\r\n    if (\r\n      (this.otherFormEndpoint && this.otherFormName) ||\r\n      this.isEditionPersonnalise\r\n    ) {\r\n      let reportToTemplateId: number;\r\n      let modalSize = ModalSizeEnum.Large;\r\n      let config: DynamicDialogConfig = {\r\n        maximizable: true,\r\n        width: modalSize.width,\r\n        height: modalSize.height,\r\n        data: {\r\n          mode: Modes.create,\r\n          isEditionPersonnalise: this.isEditionPersonnalise,\r\n          fromEndpoint: this.otherFormEndpoint,\r\n          businessClass: this.businessClass,\r\n          customReportingMode: this.customReportingMode\r\n        },\r\n      };\r\n\r\n      this._dialogRef = this._tsiModalService.open(\r\n        AddReportPopupComponent,\r\n        config\r\n      );\r\n\r\n      this._dialogRef.onClose.subscribe((val: any) => {\r\n        if (val === null || val === undefined) return;\r\n        console.log(val);\r\n\r\n        if (this.isReportForFiche) {\r\n          val.endPointValue = val?.endPointValue?.replace(\r\n            '{id}',\r\n            this.entityId\r\n          );\r\n          val.endPointKey = val?.endPointKey?.replace('{id}', this.entityId);\r\n        }\r\n\r\n        this.reportingService\r\n          .addReportToModel(\r\n            this._newReportToTemplate(\r\n              val.reportType,\r\n              val.reportName,\r\n              val.endPointValue,\r\n              val.module,\r\n              val.triOrdre,\r\n              val.reportNameAbrege,\r\n              val.display\r\n            )\r\n          )\r\n          .subscribe({\r\n            next: (value) => {\r\n              this.isloading = true;\r\n              reportToTemplateId = value;\r\n              let urlDesigner;\r\n              let tenantUid =\r\n                this.identityManagerService.parseMyAuthToken()?.tenantUid;\r\n\r\n              if (val.reportType === TsiReportType.List) {\r\n                urlDesigner = `${Segment.reportingServiceBase}/report-designer/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;\r\n              } else if (val.reportType === TsiReportType.Dashboard) {\r\n                urlDesigner = `${Segment.appBaseHref}/${this.dashboardModuleRoute}/${ManageReportingRoutes.dashboardDesigner}?${queryParamNamesConst.reportToTemplate}=${reportToTemplateId}&${queryParamNamesConst.tenantUid}=${tenantUid}`;\r\n              } else if (val.reportType === TsiReportType.RTF) {\r\n                urlDesigner = `${Segment.reportingServiceBase}/mailmerge/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;\r\n              }\r\n\r\n              window.open(urlDesigner, '_blank');\r\n\r\n              this.notificationService.success(\r\n                'shared_reporting_redirected_to_new_report_successfully'\r\n              );\r\n              this.isloading = false;\r\n            },\r\n            error: () => {\r\n              this.isloading = false;\r\n              this.notificationService.error(this.errorMessageKey);\r\n            },\r\n          });\r\n\r\n        this._closeModal(val);\r\n      });\r\n    }\r\n  }\r\n\r\n  private _closeModal(val: any): void {\r\n    if (this._dialogRef) {\r\n      this._dialogRef.destroy();\r\n    }\r\n  }\r\n\r\n  async onFormChange() {\r\n    await this._refreshReports();\r\n  }\r\n\r\n  onImportFileToReportModalCancelClick(): void {\r\n    this._hideImportFileToReportDialog();\r\n  }\r\n\r\n  onImportFileToReportModalSaveClick(): void {\r\n    this._showImportFileToReportDialog();\r\n  }\r\n  //#region file import\r\n  onImportFileToReport_FileSelected(event: any): void {\r\n    const file: File = event.currentFiles[0];\r\n    this.toUploadToUpdateReportFileData = file;\r\n  }\r\n\r\n  onImportFileToReport_ImportFile(event: any): void {\r\n    if (this.selectedReportToUpdateFromFile) {\r\n      this.reportingService\r\n        .updateReportLayout(\r\n          this.selectedReportToUpdateFromFile,\r\n          this.toUploadToUpdateReportFileData\r\n        )\r\n        .subscribe({\r\n          next: async (response) => {\r\n            await this._refreshReports();\r\n            this.notificationService.success(\r\n              'shared_reporting_report_uploaded_successfully'\r\n            );\r\n            this.importFileToReportFileUpload?.clear();\r\n            this._hideImportFileToReportDialog();\r\n          },\r\n          error: () => {\r\n            this.notificationService.error(this.errorMessageKey);\r\n          },\r\n        });\r\n    }\r\n  }\r\n\r\n  //cancel button click\r\n  onImportFileToReport_Clear(event: any): void {\r\n    this.toUploadToUpdateReportFileData = undefined;\r\n  }\r\n\r\n  //cancel button click\r\n  onImportFileToReport_Remove(event: any): void {\r\n    this.toUploadToUpdateReportFileData = undefined;\r\n  }\r\n  //#endregion\r\n\r\n  //#endregion\r\n\r\n  //#region private methods\r\n  private getFormName(formName: string) {\r\n    if (this.config?.data?.reportDiscriminator)\r\n      return `${formName}_${this.config.data.reportDiscriminator}`;\r\n    else return formName;\r\n  }\r\n\r\n  private async _refreshReports(refreshReportList: boolean = false) {\r\n    this.isloading = true;\r\n    let formName = this.otherFormName\r\n      ? this.otherFormName\r\n      : this.EDITION_PERSONNALISE;\r\n\r\n    try {\r\n      let items = await firstValueFrom(this.reportingService.getReports(formName, this.reportDiscriminator))\r\n      this.reports = items.map((r) => {\r\n        return {\r\n          ...r,\r\n          reportTypeName:\r\n            ManageReportingComponent.reportTypeLabels[r.reportType] ||\r\n            'Unknown',\r\n        };\r\n      });\r\n      this.isloading = false;\r\n    } catch (error: any) {\r\n      this.notificationService.error(this.errorMessageKey);\r\n      this.isloading = false;\r\n    }\r\n\r\n    if (refreshReportList) {\r\n      try {\r\n        //get default report templates for this form\r\n        let result = await firstValueFrom(this.reportingService.getDefaultReportTemplate(formName))\r\n        this.defaultReportTemplateData = result?.data;\r\n      } catch (error) {\r\n\r\n      }\r\n    }\r\n  }\r\n\r\n  _viewReport(uid: string): void {\r\n    // if (this.otherFormEndpoint && uid) {\r\n    this.isloading = true;\r\n\r\n    let report = this.reports.find((r) => r.uid === uid);\r\n    if (report === undefined || report === null) {\r\n      this.notificationService.error(this.errorMessageKey);\r\n      return;\r\n    }\r\n\r\n    this.reportingService\r\n      .addReportToPrint(\r\n        this._newReportToPrint(uid, report.reportType, report?.restEndpoint)\r\n      )\r\n      .subscribe({\r\n        next: (data: any) => {\r\n          let reportToTemplateId = data.uid;\r\n          let urlDesigner;\r\n          let tenantUid =\r\n            this.identityManagerService.parseMyAuthToken()?.tenantUid;\r\n          if (data.reportType === TsiReportType.List) {\r\n            urlDesigner = `${Segment.reportingServiceBase}/report-viewer/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;\r\n          } else if (data.reportType === TsiReportType.Dashboard) {\r\n            urlDesigner = `${Segment.appBaseHref}/${this.dashboardModuleRoute}/${ManageReportingRoutes.dashboardDesigner}?${queryParamNamesConst.reportToPrint}=${reportToTemplateId}&${queryParamNamesConst.tenantUid}=${tenantUid}`;\r\n          }\r\n\r\n          window.open(urlDesigner, '_blank');\r\n          this.notificationService.success(\r\n            'shared_reporting_redirected_to_print_report_successfully'\r\n          );\r\n          this.isloading = false;\r\n        },\r\n\r\n        error: (error) => {\r\n          this.notificationService.error(this.errorMessageKey);\r\n          this.isloading = false;\r\n        },\r\n\r\n        complete: () => { },\r\n      });\r\n    // }\r\n  }\r\n\r\n  _sendReport(uid: string): void {\r\n   // this.isloading = true;\r\n\r\n    //get email parameters\r\n    // this._parametresApplicationPaieService\r\n    //   .getParametreApplicationPaie()\r\n    //   .subscribe((data) => {\r\n    //     this.parametre = data;\r\n    //   });\r\n\r\n    // let report = this.reports.find((r) => r.uid === uid);\r\n    // if (report === undefined || report === null) {\r\n    //   this.notificationService.error(this.errorMessageKey);\r\n    //   return;\r\n    // }\r\n\r\n    // this.reportingService\r\n    //   .addReportToPrint(\r\n    //     this._newReportToPrint(uid, report.reportType, report?.restEndpoint)\r\n    //   )\r\n    //   .subscribe({\r\n    //     next: (data: any) => {\r\n    //       if (data != null && data != undefined) {\r\n    //         this.reportToPrintId = data.uid;\r\n\r\n    //         let modalSize = ModalSizeEnum.ExtraLarge;\r\n    //         let saveSubject: Subject<any> = new Subject();\r\n    //         let conf: DynamicDialogConfig = {\r\n    //           data: { saveSubject },\r\n    //           maximizable: true,\r\n    //           width: modalSize.width,\r\n    //           height: modalSize.height,\r\n    //         };\r\n    //         this._dialogRef = this._dialogService.open(\r\n    //           TsiSendMailComponent,\r\n    //           conf\r\n    //         );\r\n    //         saveSubject.subscribe((val: any) => {\r\n    //           this.reportingService\r\n    //             .exportReportFileToPdf(this.reportToPrintId!.toString())\r\n    //             .subscribe(\r\n    //               (blob) => {\r\n    //                 if (!this.parametre.attachments) {\r\n    //                   this.parametre.attachments = [];\r\n    //                 }\r\n    //                 const newFile = new File([blob], 'Report.pdf', {\r\n    //                   type: blob.type,\r\n    //                 });\r\n\r\n    //                 this.parametre.attachments.push(newFile);\r\n    //                 this._parametresApplicationPaieService\r\n    //                   .sendMail(\r\n    //                     this.parametre.fromAddress,\r\n    //                     this._dialogDataService.getData()?.toAddress,\r\n    //                     this._dialogDataService.getData()?.objet,\r\n    //                     this._dialogDataService.getData()?.message,\r\n    //                     this.parametre.attachments,\r\n    //                     this.parametre.host,\r\n    //                     this.parametre.credentialUser,\r\n    //                     this.parametre.credentialPWD,\r\n    //                     this.parametre.port,\r\n    //                     this.parametre.fromName,\r\n    //                     this._dialogDataService.getData()?.ccAddress\r\n    //                   )\r\n    //                   .subscribe({\r\n    //                     next: () => {\r\n    //                       this.notificationService.info(\r\n    //                         this.localization.transform(\r\n    //                           LocalizationKeys.savedSuccessfully\r\n    //                         )\r\n    //                       );\r\n    //                       this.isloading = false;\r\n    //                     },\r\n    //                     error: (response: HttpErrorResponse) => {\r\n    //                       console.log(response);\r\n    //                       this._errorResponseManagerService.showErrorMessage(\r\n    //                         response\r\n    //                       );\r\n    //                     },\r\n    //                   });\r\n    //               },\r\n    //               (error) => {\r\n    //                 console.error('Error downloading the PDF', error);\r\n    //               }\r\n    //             );\r\n    //           this.notificationService.success(\r\n    //             'shared_reporting_redirected_to_print_report_successfully'\r\n    //           );\r\n    //         });\r\n\r\n    //         this._dialogRef.onClose.subscribe((val?: any) => {\r\n    //           this._closeModal(val);\r\n    //         });\r\n    //       }\r\n    //     },\r\n\r\n    //     error: (error) => {\r\n    //       this.notificationService.error(this.errorMessageKey);\r\n    //       this.isloading = false;\r\n    //     },\r\n\r\n    //     complete: () => { },\r\n    //   });\r\n  }\r\n\r\n\r\n  _editReport(uid: string): void {\r\n    this.isloading = true;\r\n\r\n    let report = this.reports.find((r) => r.uid === uid);\r\n\r\n    if (report === undefined || report === null) {\r\n      this.notificationService.error(this.errorMessageKey);\r\n      return;\r\n    }\r\n    this.reportingService\r\n      .addReportToEditTemplate(\r\n        this._newReportToEditTemplate(\r\n          uid,\r\n          report.reportType,\r\n          report?.restEndpoint,\r\n          report?.module,\r\n          report?.order,\r\n          report?.reportName,\r\n          report?.shortName,\r\n          report?.display\r\n        )\r\n      )\r\n      .subscribe({\r\n        next: (value: any) => {\r\n          console.log(value);\r\n\r\n          if (this.isReportForFiche) {\r\n            const guidRegex = /[0-9a-fA-F-]{36}/;\r\n            value.restEndpoint = value?.restEndpoint?.replace(\r\n              guidRegex,\r\n              '{id}'\r\n            );\r\n          }\r\n\r\n          let config: DynamicDialogConfig = {\r\n            maximizable: true,\r\n            width: ModalSizeEnum.Large.width,\r\n            height: ModalSizeEnum.Large.height,\r\n            data: {\r\n              value: value,\r\n              mode: Modes.edit,\r\n              isEditionPersonnalise: this.isEditionPersonnalise,\r\n              fromEndpoint: this.otherFormEndpoint\r\n                ? this.otherFormEndpoint\r\n                : report?.restEndpoint,\r\n              businessClass: this.businessClass,\r\n            },\r\n          };\r\n          this._dialogRef = this._tsiModalService.open(\r\n            AddReportPopupComponent,\r\n            config\r\n          );\r\n          this._dialogRef.onClose.subscribe((val: any) => {\r\n            if (val === null || val === undefined) return;\r\n\r\n            console.log(val);\r\n            let model: ReportToEditTemplatePayload = {\r\n              reportTemplateUid: uid,\r\n              reportName: val.reportName,\r\n              restEndpoint: this.isReportForFiche\r\n                ? this.reportingService.insertNewUidInRestEndPoint(\r\n                  val?.endPointValue,\r\n                  this.id\r\n                ) ?? this.otherFormEndpoint\r\n                : this.otherFormEndpoint,\r\n              module: val.module,\r\n              order: val.triOrdre,\r\n              shortName: val.reportNameAbrege,\r\n              display: val.display,\r\n            };\r\n\r\n            this.reportingService.editReportToEditTemplate(model).subscribe();\r\n\r\n            let reportToTemplateId = value.uid;\r\n            let urlDesigner;\r\n            let tenantUid =\r\n              this.identityManagerService.parseMyAuthToken()?.tenantUid;\r\n\r\n            let canredirect = localStorage.getItem('canRedirect');\r\n\r\n            if (value.reportType === TsiReportType.List) {\r\n              urlDesigner = `${Segment.reportingServiceBase}/report-designer-edit/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;\r\n            } else if (value.reportType === TsiReportType.Dashboard) {\r\n              urlDesigner = `${Segment.appBaseHref}/${this.dashboardModuleRoute}/${ManageReportingRoutes.dashboardDesigner}?${queryParamNamesConst.reportToEdit}=${reportToTemplateId}&${queryParamNamesConst.tenantUid}=${tenantUid}`;\r\n            } else if (value.reportType === TsiReportType.RTF) {\r\n              urlDesigner = `${Segment.reportingServiceBase}/mailmerge-edit/${reportToTemplateId}?${queryParamNamesConst.tenantUid}=${tenantUid}`;\r\n            }\r\n\r\n            if (canredirect && JSON.parse(canredirect) == true) {\r\n              window.open(urlDesigner, '_blank');\r\n            }\r\n\r\n            this.notificationService.success(\r\n              'shared_reporting_redirected_to_edit_report_successfully'\r\n            );\r\n          });\r\n\r\n          this.isloading = false;\r\n        },\r\n        error: () => {\r\n          this.notificationService.error(this.errorMessageKey);\r\n          this.isloading = false;\r\n        },\r\n      });\r\n  }\r\n\r\n  private _deleteReport(uid: string): void {\r\n    this.confirmationService.confirm(\r\n      LocalizationKeys.confirmDelete,\r\n      undefined,\r\n      (result: boolean) => {\r\n        if (result && uid != null && uid != undefined) {\r\n          this.isloading = true;\r\n          this.reportingService.deleteReport(uid).subscribe({\r\n            next: async () => {\r\n              this.notificationService.success(\r\n                LocalizationKeys.deletedSuccessfully\r\n              );\r\n              await this._refreshReports();\r\n              this.isloading = false;\r\n            },\r\n            error: (error: any) => {\r\n              this.isloading = false;\r\n              this.notificationService.error(this.errorMessageKey);\r\n            },\r\n          });\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  private _setDefaultReport(id: number): void {\r\n    this.confirmationService.confirm(\r\n      'shared_reporting_confirm_set_default_report_file',\r\n      undefined,\r\n      (result: boolean) => {\r\n        if (result && id != null && id != undefined) {\r\n          this.isloading = true;\r\n          this.reportingService.setDefaultReport(id).subscribe({\r\n            next: async () => {\r\n              this.notificationService.success(\r\n                LocalizationKeys.savedSuccessfully\r\n              );\r\n              await this._refreshReports();\r\n              this.isloading = false;\r\n            },\r\n            error: (error: any) => {\r\n              this.isloading = false;\r\n              this.notificationService.error(this.errorMessageKey);\r\n            },\r\n          });\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  private _exportReport(uid: string): void {\r\n    if (uid) {\r\n      let reportName: string = 'file-name.json';\r\n      let report = this.reports.find((r) => r.uid == uid);\r\n      if (report) {\r\n        reportName = report.name;\r\n      }\r\n      this.isloading = true;\r\n      this.reportingService.exportReportFile(uid).subscribe({\r\n        next: (response) => {\r\n          let file = new Blob([response], { type: 'application/json' });\r\n          var fileURL = URL.createObjectURL(file);\r\n          let reportRoute = fileURL;\r\n          var downloadLink = document.createElement('a');\r\n          downloadLink.download = reportName;\r\n          downloadLink.href = reportRoute;\r\n          downloadLink.click();\r\n          this.notificationService.success(\r\n            'shared_reporting_report_exported_successfully'\r\n          );\r\n          this.isloading = false;\r\n        },\r\n        error: () => {\r\n          this.notificationService.error(this.errorMessageKey);\r\n          this.isloading = false;\r\n        },\r\n      });\r\n    }\r\n  }\r\n\r\n  private _importToReport(id: number): void {\r\n    if (id) {\r\n      this.selectedReportToUpdateFromFile = id;\r\n      this._showImportFileToReportDialog();\r\n    }\r\n  }\r\n\r\n  private _newJsonDataConnection(): JsonDataConnection {\r\n    if (this.otherFormEndpoint != null && this.otherFormEndpoint != undefined) {\r\n      let newJsonDataConnection: JsonDataConnection = {\r\n        name: `${this.otherFormName}-JsonDS`,\r\n        displayName: undefined,\r\n        uri: this.otherFormEndpoint,\r\n        httpRequestContent: undefined,\r\n      };\r\n\r\n      return newJsonDataConnection;\r\n    } else {\r\n      throw Error('some of the required properties : uri have not been set !');\r\n    }\r\n  }\r\n\r\n  private _newReportToPrint(\r\n    uid: string,\r\n    reportType: number,\r\n    restEndpoint?: string,\r\n    module?: string,\r\n    order?: number,\r\n    shortName?: string,\r\n    display?: boolean\r\n  ): ReportToPrint {\r\n    let token = this.identityManagerService.getAuthToken();\r\n    let username: string | undefined =\r\n      this.identityManagerService.parseMyAuthToken().name;\r\n    if (username) {\r\n      if (uid && /*this.otherFormEndpoint && this.otherFormName &&*/ token) {\r\n        let newReportToPrint: ReportToPrint = {\r\n          reportTemplateUid: uid,\r\n          restEndpoint: this.isReportForFiche\r\n            ? this.reportingService.insertNewUidInRestEndPoint(restEndpoint, this.id) ??\r\n            this.otherFormEndpoint\r\n            : this.otherFormEndpoint,\r\n          requestData: !this.customReportingMode ? this.formEndpointBody : this.requestData,\r\n          formName: this.otherFormName,\r\n          reportType: reportType,\r\n          username: username,\r\n          userToken: reportType == TsiReportType.Dashboard ? undefined : token,\r\n          isPaged: this.isFormEndpointPaged == true ? true : false,\r\n          htmlFiltersText: this.filtersHtmlTemplate,\r\n          optionalEndpointsJson: this.optionalEndpoints,\r\n          module: module,\r\n          order: order,\r\n          shortName: shortName,\r\n          display: display,\r\n          httpMethodType: this.httpMethodType\r\n        };\r\n\r\n        return newReportToPrint;\r\n      } else {\r\n        throw Error(\r\n          'some of the required properties : user token, formName, formEndpoint or selectedReport have not been set !'\r\n        );\r\n      }\r\n    } else {\r\n      throw Error(\"property 'UserName ' of current user have not been set !\");\r\n    }\r\n  }\r\n\r\n  private _newReportToTemplate(\r\n    reportType: TsiReportType,\r\n    reportName: string,\r\n    restEndpoint: string,\r\n    module: string,\r\n    order: number,\r\n    shortName: string,\r\n    display: boolean,\r\n  ): ReportToTemplate {\r\n    let token = this.identityManagerService.getAuthToken();\r\n\r\n    if (this.otherFormEndpoint && this.otherFormName && token) {\r\n      let reportToTemplate: ReportToTemplate = {\r\n        restEndpoint: restEndpoint,\r\n        requestData: !this.customReportingMode ? this.formEndpointBody : \r\n        this.requestData,\r\n        formEntity: this.otherFormName, //this.getFormName(this.otherFormName), //this.otherFormName,\r\n        userToken: reportType == TsiReportType.Dashboard ? undefined : token,\r\n        reportName: reportName,\r\n        isPaged: this.isFormEndpointPaged == true ? true : false,\r\n        reportType: reportType, //this.isFormEndpointPaged == true ? TsiReportType.List : TsiReportType.Form,\r\n        optionalEndpointsJson: this.optionalEndpoints,\r\n        htmlFiltersText: this.filtersHtmlTemplate,\r\n        module: module,\r\n        order: order,\r\n        shortName: shortName,\r\n        display: display,\r\n        descriminatorValue: this.reportDiscriminator,\r\n        httpMethodType: this.httpMethodType\r\n      };\r\n      console.log(reportToTemplate);\r\n      return reportToTemplate;\r\n    } else {\r\n      let reportToTemplate: ReportToTemplate = {\r\n        restEndpoint: this.isReportForFiche || this.customReportingMode\r\n          ? restEndpoint!\r\n          : this.otherFormEndpoint!,\r\n        requestData: !this.customReportingMode ? JSON.stringify({\r\n          sorting: [{ property: 'UID', order: 'ASC' }],\r\n          getAllData: true,\r\n        }) : this.requestData,\r\n        formEntity: '',\r\n        userToken: reportType == TsiReportType.Dashboard ? undefined : token!,\r\n        reportName: reportName,\r\n        isPaged: this.isFormEndpointPaged == true ? true : false,\r\n        reportType: reportType, //this.isFormEndpointPaged == true ? TsiReportType.List : TsiReportType.Form,\r\n        optionalEndpointsJson: this.optionalEndpoints,\r\n        htmlFiltersText: this.filtersHtmlTemplate,\r\n        module: module,\r\n        order: order,\r\n        shortName: shortName,\r\n        display: display,\r\n      };\r\n\r\n      return reportToTemplate;\r\n      // throw Error('some of the required properties : user token, formName or formEndpoint have not been set !');\r\n    }\r\n  }\r\n\r\n  private _newReportToEditTemplate(\r\n    uid: string,\r\n    reportType: TsiReportType,\r\n    restEndPoint?: string,\r\n    module?: string,\r\n    order?: number,\r\n    reportName?: string,\r\n    shortName?: string,\r\n    display?: boolean\r\n  ): ReportToEditTemplate {\r\n    let token = this.identityManagerService.getAuthToken();\r\n    let username: string | undefined =\r\n      this.identityManagerService.parseMyAuthToken().name;\r\n\r\n    if (username) {\r\n      if (uid && /*this.otherFormEndpoint && this.otherFormName &&*/ token) {\r\n        let reportToEditTemplate: ReportToEditTemplate = {\r\n          restEndpoint: this.isReportForFiche\r\n            ? this.reportingService.insertNewUidInRestEndPoint(restEndPoint, this.id) ??\r\n            this.otherFormEndpoint\r\n            : this.otherFormEndpoint,\r\n          requestData: !this.customReportingMode ? this.formEndpointBody : this.requestData,\r\n          formName: this.otherFormName, // this.getFormName(this.otherFormName!),\r\n          reportTemplateUid: uid,\r\n          reportType: reportType,\r\n          username: username,\r\n          userToken: reportType == TsiReportType.Dashboard ? undefined : token,\r\n          isPaged: this.isFormEndpointPaged == true ? true : false,\r\n          optionalEndpointsJson: this.optionalEndpoints,\r\n          htmlFiltersText: this.filtersHtmlTemplate,\r\n          module: module,\r\n          order: order,\r\n          reportName: reportName,\r\n          shortName: shortName,\r\n          display: display,\r\n          httpMethodType: this.httpMethodType\r\n        };\r\n        return reportToEditTemplate;\r\n      } else {\r\n        throw Error(\r\n          'some of the required properties : user token or selectedReport have not been set !'\r\n        );\r\n      }\r\n    } else {\r\n      this.isloading = false;\r\n      throw Error(\"property 'UserName ' of current user have not been set !\");\r\n    }\r\n  }\r\n\r\n  private _refreshReportsJob(): void {\r\n    console.warn('Refresh Reports Job at : ', new Date());\r\n    //\r\n    if (this.otherFormName != null && this.otherFormName != undefined) {\r\n      this.reportingService.getReports(this.otherFormName, this.reportDiscriminator).subscribe({\r\n        next: (items) => {\r\n          this.reports = items;\r\n\r\n          if (this.previousFormName != this.otherFormName) {\r\n            this.notificationService.success(\r\n              LocalizationKeys.retrievedSuccessfully\r\n            );\r\n            this.previousFormName = this.otherFormName ?? '';\r\n          }\r\n\r\n          //\r\n          this.refreshJobTimeOut = setTimeout(() => {\r\n            this._refreshReportsJob();\r\n          }, 10000);\r\n        },\r\n        error: (err: any) => {\r\n          this.notificationService.error(this.errorMessageKey);\r\n          this.refreshJobTimeOut = setTimeout(() => {\r\n            this._refreshReportsJob();\r\n          }, 10000);\r\n        },\r\n        complete: () => { },\r\n      });\r\n    } else {\r\n      this.refreshJobTimeOut = setTimeout(() => {\r\n        this._refreshReportsJob();\r\n      }, 10000);\r\n    }\r\n  }\r\n\r\n  private _showImportFileToReportDialog(): void {\r\n    this.isUpdateReportFromFileDialogVisible = true;\r\n  }\r\n\r\n  private _hideImportFileToReportDialog(): void {\r\n    this.isUpdateReportFromFileDialogVisible = false;\r\n    this.toUploadToUpdateReportFileData = undefined;\r\n  }\r\n\r\n  // getDefaultReportTemplate(){\r\n  previewBuiltInReportTemplate(templateName: string) {\r\n    let url: string = `${Segment.reportingServiceBase}/report-viewer/${this.otherFormName}/${templateName}`;\r\n    window.open(url, '_blank');\r\n  }\r\n\r\n  //add a report from the built-in model to the user list\r\n  _addFromBuiltInTemplates(templateName: any) {\r\n    let formName = this.otherFormName ?? this.EDITION_PERSONNALISE;\r\n    this.reportingService\r\n      .addFromBuiltInTemplate(formName, templateName, this.reportDiscriminator)\r\n      .subscribe({\r\n        next: async (res) => {\r\n          if (res && res.isSuccess === true) {\r\n            await this._refreshReports();\r\n            this.notificationService.info(res.msg);\r\n          } else\r\n            this.notificationService.warn(\r\n              'shared_reporting_cannot_add_from_built_in_template'\r\n            );\r\n        },\r\n        error: (err) => {\r\n          this.notificationService.warn(\r\n            'shared_reporting_cannot_add_from_built_in_template'\r\n          );\r\n        },\r\n      });\r\n  }\r\n\r\n  //add a report from the user list to built-in model template\r\n  _addToBuiltInTemplates(reportId: string) {\r\n    this.reportingService.addToBuiltInTemplate(reportId).subscribe({\r\n      next: async (res) => {\r\n        await this._refreshReports(true);\r\n        this.notificationService.info(LocalizationKeys.savedSuccessfully);\r\n      },\r\n      error: (err) => {\r\n        this.notificationService.warn(\r\n          'shared_reporting_add_to_builtin_template_report_failed'\r\n        );\r\n      },\r\n    });\r\n  }\r\n  //#endregion\r\n\r\n  //#region make report layout as default for all reports\r\n  makeReportDefaultLayout(reportUid: string) {\r\n    let request = {\r\n      reportTemplateUid: reportUid,\r\n    };\r\n    this.reportingService.makeReportLayoutAsDefaultLayout(request).subscribe({\r\n      next: (data) => {\r\n        console.log(data);\r\n        this.notificationService.success('shared_reporting_success_updated');\r\n      },\r\n      error: (error: HttpErrorResponse) => {\r\n        this.notificationService.warn('shared_reporting_error_occured');\r\n      },\r\n    });\r\n  }\r\n  //#end region\r\n\r\n  _viewDashboardt(uid: string): void {\r\n    this.isloading = true;\r\n\r\n    let report = this.reports.find((r) => r.uid === uid);\r\n    if (!report) {\r\n      this.notificationService.error(this.errorMessageKey);\r\n      return;\r\n    }\r\n\r\n    let reportTemplateId = report.uid;\r\n    let tenantUid = this.identityManagerService.parseMyAuthToken()?.tenantUid;\r\n\r\n    let urlViewer = `${Segment.appBaseHref}/${this.dashboardModuleRoute}/${ManageReportingRoutes.dashboardViewer}?${queryParamNamesConst.reportTemplate}=${reportTemplateId}&${queryParamNamesConst.tenantUid}=${tenantUid}`;\r\n\r\n    console.log('>>> _viewDashboardt ~ urlViewer:', urlViewer);\r\n\r\n    window.open(urlViewer, '_blank');\r\n    this.notificationService.success(\r\n      'shared_reporting_redirected_to_print_report_successfully'\r\n    );\r\n    this.isloading = false;\r\n  }\r\n}\r\n","\r\n<div class=\"card\">\r\n  <div *busy=\"isloading\"></div>\r\n  <div class=\"grid\">\r\n    <div class=\"grid col-10\">\r\n      <div *ngIf=\"isFromForm; else notFromForm\">\r\n        <Tsi-Label class=\"col-2\" [labelValue]=\"'shared_reporting_form'\">\r\n        </Tsi-Label>\r\n        <p-dropdown class=\"col-10 tsi-component\" class=\"tsi-component\" styleClass=\"tsi-component\" appendTp=\"body\"\r\n          [options]=\"formNames\" [ngModel]=\"otherFormName\" optionLabel=\"value\" optionValue=\"key\" [filter]=\"true\"\r\n          filterBy=\"value\" [showClear]=\"true\" placeholder=\"{{'shared_reporting_select_form' | localize}}\"\r\n          [disabled]=\"true\">\r\n        </p-dropdown>\r\n      </div>\r\n\r\n      <ng-template #notFromForm>\r\n        <ng-container>\r\n          <Tsi-Label class=\"col-2\" [labelValue]=\"'shared_reporting_form'\">\r\n          </Tsi-Label>\r\n          <Tsi-Search-Combo class=\"col-10\" [(bind)]=\"otherFormName\" (bindChange)=\"onFormChange()\"\r\n            [listSourceUrl]=\"getFormNamesEndpoint\" [elementSourceUrl]=\"getFormNamesEndpoint \" [isFiltered]=\"true\"\r\n            id-field=\"key\" label-field=\"value\">\r\n          </Tsi-Search-Combo>\r\n        </ng-container>\r\n      </ng-template>\r\n    </div>\r\n  </div>\r\n\r\n  <p-toolbar styleClass=\"mb-4 gap-2\">\r\n    <ng-template pTemplate=\"left\">\r\n      <Tsi-Button [text]=\"'shared_reporting_add_report' | localize\" icon=\"p-button-icon p-button-icon-left pi pi-plus\"\r\n        styleClass=\"p-element p-button-success ml-2 mr-2 p-button p-component ng-star-inserted p-button-label\" (click)=\"onNewReport()\"></Tsi-Button>\r\n      <Tsi-Button [buttonType]=\"buttonType.Submit\" [text]=\"'shared_reporting_delete_report' | localize\" icon=\"p-button-icon p-button-icon-left pi pi-trash\"\r\n        styleClass=\"p-element p-button-danger p-button p-component ng-star-inserted p-button-label\" (click)=\"onDeleteSelectedReports()\"\r\n        [disabled]=\"!selectedReports || !selectedReports.length\"></Tsi-Button>\r\n    </ng-template>\r\n\r\n    <ng-template pTemplate=\"right\">\r\n      <p-fileUpload #fileUpload name=\"demo[]\" (onBeforeUpload)=\"onImportFile($event)\"\r\n        (onSelect)=\"onFileSelected($event)\" (onClear)=\"onClear($event)\" (onRemove)=\"onRemove($event)\" [multiple]=\"false\"\r\n        accept=\"application/json\" [maxFileSize]=\"10000000\" \r\n        [invalidFileSizeMessageSummary]=\"'shared_file_upload_invalid_file_size_message_summary' | localize\"\r\n        [invalidFileSizeMessageDetail]=\"'shared_file_upload_invalid_file_size_message_detail' | localize\"\r\n        [invalidFileTypeMessageSummary]=\"'shared_file_upload_invalid_file_type_message_summary' | localize\"\r\n        [invalidFileLimitMessageDetail]=\"'shared_file_upload_invalid_file_limit_message_detail' | localize\"\r\n        [invalidFileLimitMessageSummary]=\"'shared_file_upload_invalid_file_limit_message_summary' | localize\"\r\n        [invalidFileTypeMessageDetail]=\"'shared_file_upload_invalid_file_type_message_detail' | localize\"\r\n        [chooseIcon]=\"'pi pi-paperclip'\" cancelStyleClass=\"p-button-secondary\" uploadStyleClass=\"p-button-help\"\r\n        removeStyleClass=\"p-button-danger\" [chooseLabel]=\"'shared_reporting_choose_report_file' | localize\"\r\n        [uploadLabel]=\"'shared_reporting_import_report' | localize\"\r\n        [cancelLabel]=\"'shared_reporting_cancel_choose_report_file' | localize\">\r\n        <ng-template *ngIf=\"toUploadFileData\" pTemplate=\"fileupload-content\">\r\n        </ng-template>\r\n      </p-fileUpload>\r\n    </ng-template>\r\n  </p-toolbar>\r\n\r\n  <!-- <Tsi-Display-Grid [showHeader]=\"true\"\r\n    [header]=\"'shared_reporting_my_template'\"\r\n    [columns]=\"columns\" [gridData]=\"reports\" key=\"uid\"\r\n    (buttonColumnClicked)=\"handleButtonColumnClicked($event)\" [(selectedItems)]=\"selectedReports\"\r\n    [showFilters]=\"false\"\r\n    [paginator]=\"true\"\r\n    [globalFilterFields]=\"globalFilterFields\">\r\n  </Tsi-Display-Grid> -->\r\n\r\n\r\n  <!--<div style=\"text-align:left\"> <p-button icon=\"pi pi-refresh\"  [pTooltip]=\"'shared_reporting_refresh' | localize\" [tooltipPosition]=\"tooltipPosition.Top\"  label=\"Reload\" severity=\"help\" (click)=\"onRefresh()\" /> </div>\r\n  <p-button icon=\"pi pi-refresh\" class=\"p-button-rounded\" styleClass=\"p-button-text\" />\r\n-->\r\n  \r\n  <Tsi-Button styleClass=\"p-element p-button-text p-button-raised p-button-rounded mb-3 ml-3\"  \r\n    [tooltipText]=\"'shared_reporting_refresh'\" [tooltipPosition]=\"tooltipPosition.Top\"\r\n    icon=\"pi pi-refresh\" (click)=\"onRefresh()\"></Tsi-Button>\r\n\r\n  <tsi-view-grid \r\n    [header]=\"'shared_reporting_my_template'\"\r\n    [columns]=\"columns\" [gridData]=\"reports\" key=\"uid\"\r\n    (buttonColumnClicked)=\"handleButtonColumnClicked($event)\" [(selectedItems)]=\"selectedReports\"\r\n    [getDataFromApi]=\"false\"\r\n    [formName]=\"'my-report-templates'\"\r\n    >\r\n  </tsi-view-grid>\r\n  <br/>\r\n   <!-- Default Template -->\r\n   <!-- <Tsi-Display-Grid \r\n   [showHeader]=\"true\" \r\n   [header]=\"'shared_reporting_BuiltIn_template'\"\r\n   [showSummaryFooter]=\"false\" \r\n   [paginator]=\"false\" \r\n   [showFilters]=\"false\" \r\n   [columns]=\"defaultTemplateColumns\" \r\n   [gridData]=\"defaultReportTemplateData\" \r\n   (buttonColumnClicked)=\"handleButtonColumnClicked($event)\"\r\n   [paginator]=\"true\"\r\n   key=\"name\">\r\n  </Tsi-Display-Grid> -->\r\n\r\n  \r\n  <tsi-view-grid\r\n   [header]=\"'shared_reporting_BuiltIn_template'\"\r\n   [columns]=\"defaultTemplateColumns\" \r\n   [gridData]=\"defaultReportTemplateData\" \r\n   (buttonColumnClicked)=\"handleButtonColumnClicked($event)\"\r\n   [getDataFromApi]=\"false\"\r\n   [formName]=\"'default-my-report-templates'\"\r\n   key=\"name\">\r\n  </tsi-view-grid>\r\n\r\n\r\n\r\n\r\n  \r\n\r\n  <!-- dialog to import file to report -->\r\n  <p-dialog header=\"{{'shared_reporting_select_file_to_import_into_report' | localize}}\" [(visible)]=\"isUpdateReportFromFileDialogVisible\" [style]=\"{width: '50vw'}\">\r\n    <!-- <Tsi-Modal-Header (onCloseClick)=\"onImportFileToReportModalCancelClick()\" [inputTitle]=\"'shared_reporting_select_file_to_import_into_report'\"></Tsi-Modal-Header> -->\r\n\r\n    <ng-template pTemplate=\"body\">\r\n      <p-fileUpload #importFileToReportFileUpload name=\"importFileToReport\" (onBeforeUpload)=\"onImportFileToReport_ImportFile($event)\"\r\n        (onSelect)=\"onImportFileToReport_FileSelected($event)\" (onClear)=\"onImportFileToReport_Clear($event)\" (onRemove)=\"onImportFileToReport_Remove($event)\" [multiple]=\"false\"\r\n        accept=\"application/json\" [maxFileSize]=\"10000000\"\r\n        [invalidFileSizeMessageSummary]=\"'shared_file_upload_invalid_file_size_message_summary' | localize\"\r\n        [invalidFileSizeMessageDetail]=\"'shared_file_upload_invalid_file_size_message_detail' | localize\"\r\n        [invalidFileTypeMessageSummary]=\"'shared_file_upload_invalid_file_type_message_summary' | localize\"\r\n        [invalidFileLimitMessageDetail]=\"'shared_file_upload_invalid_file_limit_message_detail' | localize\"\r\n        [invalidFileLimitMessageSummary]=\"'shared_file_upload_invalid_file_limit_message_summary' | localize\"\r\n        [invalidFileTypeMessageDetail]=\"'shared_file_upload_invalid_file_type_message_detail' | localize\"\r\n        [chooseIcon]=\"'pi pi-paperclip'\" cancelStyleClass=\"p-button-secondary\" uploadStyleClass=\"p-button-help\"\r\n        removeStyleClass=\"p-button-danger\" [chooseLabel]=\"'shared_reporting_choose_report_file' | localize\"\r\n        [uploadLabel]=\"'shared_reporting_import_report' | localize\"\r\n        [cancelLabel]=\"'shared_reporting_cancel_choose_report_file' | localize\">\r\n        <ng-template *ngIf=\"toUploadToUpdateReportFileData\" pTemplate=\"fileupload-content\">\r\n        </ng-template>\r\n      </p-fileUpload>\r\n    </ng-template>\r\n\r\n    <!-- <Tsi-Modal-Footer (onCancelClick)=\"onImportFileToReportModalCancelClick()\"\r\n    (onSaveClick)=\"onImportFileToReportModalSaveClick()\"\r\n    [saveDisabled]=\"!toUploadToUpdateReportFileData\"></Tsi-Modal-Footer> -->\r\n\r\n</p-dialog>\r\n</div>\r\n"]}