@arsedizioni/ars-utils 18.2.365 → 18.2.371

package/fesm2022/arsedizioni-ars-utils-evolution.common.mjs

@@ -0,0 +1,817 @@
+import * as i0 from '@angular/core';
+import { inject, signal, Injectable, NgModule } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
+import { BroadcastService, SystemUtils } from '@arsedizioni/ars-utils/core';
+import { DialogService } from '@arsedizioni/ars-utils/ui';
+import { throwError, of, catchError as catchError$1, switchMap } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+
+const EvolutionMessages = {
+    // Login
+    LOGIN_CHANGED: '§evo-login-changed',
+    LOGIN_COMPLETED: '§evo-login-completed',
+    LOGOUT_COMPLETED: '§evo-logout-completed',
+    LOGOUT: '§evo-logout'
+};
+
+var ERPComplianceLawsSelectionType;
+(function (ERPComplianceLawsSelectionType) {
+    ERPComplianceLawsSelectionType[ERPComplianceLawsSelectionType["Analysis"] = 1] = "Analysis";
+    ERPComplianceLawsSelectionType[ERPComplianceLawsSelectionType["Activity"] = 2] = "Activity";
+})(ERPComplianceLawsSelectionType || (ERPComplianceLawsSelectionType = {}));
+var ERPComplianceProfileRole;
+(function (ERPComplianceProfileRole) {
+    ERPComplianceProfileRole[ERPComplianceProfileRole["None"] = 0] = "None";
+    ERPComplianceProfileRole[ERPComplianceProfileRole["Analyst"] = 1] = "Analyst";
+    ERPComplianceProfileRole[ERPComplianceProfileRole["Planner"] = 2] = "Planner";
+    ERPComplianceProfileRole[ERPComplianceProfileRole["Validator"] = 4] = "Validator";
+    ERPComplianceProfileRole[ERPComplianceProfileRole["Executor"] = 8] = "Executor";
+    ERPComplianceProfileRole[ERPComplianceProfileRole["Observer"] = 16] = "Observer";
+})(ERPComplianceProfileRole || (ERPComplianceProfileRole = {}));
+var ERPComplianceProfileFlags;
+(function (ERPComplianceProfileFlags) {
+    ERPComplianceProfileFlags[ERPComplianceProfileFlags["OverrideNotificationRegisterSettings"] = 16] = "OverrideNotificationRegisterSettings";
+})(ERPComplianceProfileFlags || (ERPComplianceProfileFlags = {}));
+var ERPComplianceScope;
+(function (ERPComplianceScope) {
+    ERPComplianceScope[ERPComplianceScope["None"] = 0] = "None";
+    ERPComplianceScope[ERPComplianceScope["Environment"] = 1] = "Environment";
+    ERPComplianceScope[ERPComplianceScope["Safety"] = 2] = "Safety";
+    ERPComplianceScope[ERPComplianceScope["FoodSafety"] = 4] = "FoodSafety";
+    ERPComplianceScope[ERPComplianceScope["Energy"] = 8] = "Energy";
+    ERPComplianceScope[ERPComplianceScope["Health"] = 16] = "Health";
+    ERPComplianceScope[ERPComplianceScope["Maintenance"] = 32] = "Maintenance";
+    ERPComplianceScope[ERPComplianceScope["Quality"] = 64] = "Quality";
+    ERPComplianceScope[ERPComplianceScope["Organization"] = 128] = "Organization";
+    ERPComplianceScope[ERPComplianceScope["Logistics"] = 256] = "Logistics";
+    ERPComplianceScope[ERPComplianceScope["Facility"] = 512] = "Facility";
+    ERPComplianceScope[ERPComplianceScope["Security"] = 1024] = "Security";
+})(ERPComplianceScope || (ERPComplianceScope = {}));
+var ERPComplianceNotificationLimit;
+(function (ERPComplianceNotificationLimit) {
+    ERPComplianceNotificationLimit[ERPComplianceNotificationLimit["None"] = 0] = "None";
+    ERPComplianceNotificationLimit[ERPComplianceNotificationLimit["PlannerOnly"] = 1] = "PlannerOnly";
+    ERPComplianceNotificationLimit[ERPComplianceNotificationLimit["ExecutorOnly"] = 2] = "ExecutorOnly";
+    ERPComplianceNotificationLimit[ERPComplianceNotificationLimit["Both"] = 3] = "Both";
+})(ERPComplianceNotificationLimit || (ERPComplianceNotificationLimit = {}));
+var ERPComplianceRegisterNotificationType;
+(function (ERPComplianceRegisterNotificationType) {
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["None"] = 0] = "None";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["NewAnalysis"] = 1] = "NewAnalysis";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["AnalysisCompleted"] = 2] = "AnalysisCompleted";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["AnalysisNoticePeriodStarted"] = 4] = "AnalysisNoticePeriodStarted";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["AnalysisPeriodExpired"] = 8] = "AnalysisPeriodExpired";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["AnalysisLawChanged"] = 16384] = "AnalysisLawChanged";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["NewPlanning"] = 8192] = "NewPlanning";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["PlanningCompleted"] = 16] = "PlanningCompleted";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["PlanningNoticePeriodStarted"] = 32] = "PlanningNoticePeriodStarted";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["PlanningPeriodExpired"] = 64] = "PlanningPeriodExpired";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["NewValidation"] = 32768] = "NewValidation";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["ValidationCompleted"] = 128] = "ValidationCompleted";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["ValidationNoticePeriodStarted"] = 256] = "ValidationNoticePeriodStarted";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["ValidationPeriodExpired"] = 512] = "ValidationPeriodExpired";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["NewDeadline"] = 65536] = "NewDeadline";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["DeadlineNoticePeriodStarted"] = 1024] = "DeadlineNoticePeriodStarted";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["DeadlineExpired"] = 2048] = "DeadlineExpired";
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["ActivityCompleted"] = 4096] = "ActivityCompleted";
+    //NewNoncompliance = 1 << 17,
+    //NonComplianceNoticePeriodStarted = 1 << 18,
+    //NonCompliancePeriodExpired = 1 << 19,
+    //NonComplianceCompleted = 1 << 20,
+    ERPComplianceRegisterNotificationType[ERPComplianceRegisterNotificationType["LawChanged"] = 2097152] = "LawChanged";
+})(ERPComplianceRegisterNotificationType || (ERPComplianceRegisterNotificationType = {}));
+var ERPComplianceRegisterSiteImportOptions;
+(function (ERPComplianceRegisterSiteImportOptions) {
+    ERPComplianceRegisterSiteImportOptions[ERPComplianceRegisterSiteImportOptions["CopyAttachments"] = 1] = "CopyAttachments";
+    ERPComplianceRegisterSiteImportOptions[ERPComplianceRegisterSiteImportOptions["KeepOriginalDates"] = 2] = "KeepOriginalDates";
+    ERPComplianceRegisterSiteImportOptions[ERPComplianceRegisterSiteImportOptions["DuplicateLaws"] = 4] = "DuplicateLaws";
+    ERPComplianceRegisterSiteImportOptions[ERPComplianceRegisterSiteImportOptions["DiscardNotApplicables"] = 8] = "DiscardNotApplicables";
+})(ERPComplianceRegisterSiteImportOptions || (ERPComplianceRegisterSiteImportOptions = {}));
+const ProfileRoles = [
+    { name: 'Analista', value: ERPComplianceProfileRole.Analyst },
+    { name: 'Gestore', value: ERPComplianceProfileRole.Planner },
+    //{ name: 'Validatore', value: ERPComplianceProfileRole.Validator },
+    { name: 'Esecutore', value: ERPComplianceProfileRole.Executor },
+    { name: 'Osservatore', value: ERPComplianceProfileRole.Observer },
+];
+const ProfileFlags = [
+    { name: 'Deroghe e limitazioni', divider: true },
+    {
+        name: 'Questo profilo riceve regolarmente le notifiche indipendentemente dalla configurazione generale del registro',
+        value: ERPComplianceProfileFlags.OverrideNotificationRegisterSettings,
+    },
+];
+const Scopes = [
+    { name: 'Ambiente', value: ERPComplianceScope.Environment },
+    { name: 'Salute e sicurezza', value: ERPComplianceScope.Safety },
+    {
+        name: 'Sicurezza alimentare',
+        value: ERPComplianceScope.FoodSafety,
+    },
+    { name: 'Energia', value: ERPComplianceScope.Energy },
+    { name: 'Servizi generali', value: ERPComplianceScope.Facility },
+    { name: 'Manutenzione', value: ERPComplianceScope.Maintenance },
+    { name: 'Qualità', value: ERPComplianceScope.Quality },
+    { name: 'Organizzazione', value: ERPComplianceScope.Organization },
+    { name: 'Logistica', value: ERPComplianceScope.Logistics },
+    { name: 'Security', value: ERPComplianceScope.Security },
+];
+const NotificationLimits = [
+    { name: 'Nessuna limitazione', value: ERPComplianceNotificationLimit.None },
+    {
+        name: 'Solo gestore che ha pianificato',
+        value: ERPComplianceNotificationLimit.PlannerOnly,
+    },
+    {
+        name: "Solo all'incaricato designato",
+        value: ERPComplianceNotificationLimit.ExecutorOnly,
+    },
+    {
+        name: 'Solo a gestore e incaricato designato',
+        value: ERPComplianceNotificationLimit.Both,
+    },
+];
+const Notifications = [
+    { name: 'Verifica applicabilità e analisi', divider: true },
+    {
+        name: 'Richiesta analisi',
+        value: ERPComplianceRegisterNotificationType.NewAnalysis,
+    },
+    {
+        name: "Preavviso: sta per scadere il termine fissato per l'analisi",
+        value: ERPComplianceRegisterNotificationType.AnalysisNoticePeriodStarted,
+    },
+    {
+        name: "Allarme: è scaduto il termine fissato per l'analisi",
+        value: ERPComplianceRegisterNotificationType.AnalysisPeriodExpired,
+    },
+    {
+        name: 'Analisi completata',
+        value: ERPComplianceRegisterNotificationType.AnalysisCompleted,
+    },
+    {
+        name: 'Avviso norma modificata dal legislatore',
+        value: ERPComplianceRegisterNotificationType.AnalysisLawChanged,
+    },
+    { name: 'Pianificazioni', divider: true },
+    {
+        name: 'Richiesta gestione',
+        value: ERPComplianceRegisterNotificationType.NewPlanning,
+    },
+    {
+        name: 'Preavviso: sta per scadere il termine fissato per la gestione',
+        value: ERPComplianceRegisterNotificationType.PlanningNoticePeriodStarted,
+    },
+    {
+        name: 'Allarme: è scaduto il termine fissato per la gestione',
+        value: ERPComplianceRegisterNotificationType.PlanningPeriodExpired,
+    },
+    {
+        name: 'Gestione completata',
+        value: ERPComplianceRegisterNotificationType.PlanningCompleted,
+    },
+    {
+        name: 'Attività completata',
+        value: ERPComplianceRegisterNotificationType.ActivityCompleted,
+    },
+    /*{ name: 'Gestione non conformità', divider: true },
+    {
+      name: 'Apertura non comformità',
+      value: ERPComplianceRegisterNotificationType.NewNoncompliance,
+    },
+    {
+      name:
+        "Preavviso: sta per scadere il termine fissato per l'azione correttiva",
+      value:
+        ERPComplianceRegisterNotificationType.NonComplianceNoticePeriodStarted,
+    },
+    {
+      name: "Allarme: è scaduto il termine fissato per l'azione correttiva",
+      value: ERPComplianceRegisterNotificationType.NonCompliancePeriodExpired,
+    },
+    {
+      name: 'Chiusura non conformità',
+      value: ERPComplianceRegisterNotificationType.NonComplianceCompleted,
+    },*/
+    /*{ name: 'Approvazioni', divider: true },
+    { name: 'Richiesta approvazione', value: 1 << 14 },
+    {
+      name: "Preavviso: sta per scadere il termine fissato per l'approvazione",
+      value: ERPComplianceRegisterNotificationType.ValidationNoticePeriodStarted,
+    },
+    {
+      name: "Allarme: è scaduto il termine fissato per l'approvazione",
+      value: ERPComplianceRegisterNotificationType.ValidationPeriodExpired,
+    },
+    {
+      name: 'Approvazione concessa o negata',
+      value: ERPComplianceRegisterNotificationType.ValidationCompleted,
+    },*/
+    { name: 'Scadenze', divider: true },
+    {
+        name: 'Preavviso: 1° promemoria sulla data di scadenza',
+        value: ERPComplianceRegisterNotificationType.NewValidation,
+    },
+    {
+        name: 'Avviso: 2° promemoria sulla data di scadenza',
+        value: ERPComplianceRegisterNotificationType.DeadlineNoticePeriodStarted,
+    },
+    {
+        name: 'Allarme: è scaduto il termine',
+        value: ERPComplianceRegisterNotificationType.DeadlineExpired,
+    },
+    { name: 'Norme collegate', divider: true },
+    {
+        name: 'Modifica o abrogazione',
+        value: ERPComplianceRegisterNotificationType.LawChanged,
+    },
+];
+var ERPComplianceLawState;
+(function (ERPComplianceLawState) {
+    ERPComplianceLawState[ERPComplianceLawState["ApplicableOrAknowledged"] = 1] = "ApplicableOrAknowledged";
+    ERPComplianceLawState[ERPComplianceLawState["NotApplicable"] = 2] = "NotApplicable";
+    ERPComplianceLawState[ERPComplianceLawState["NotAnalyzed"] = 3] = "NotAnalyzed";
+    ERPComplianceLawState[ERPComplianceLawState["ExpiredAnalysis"] = 4] = "ExpiredAnalysis";
+    ERPComplianceLawState[ERPComplianceLawState["UpdatedLaws"] = 5] = "UpdatedLaws";
+    ERPComplianceLawState[ERPComplianceLawState["Analyzed"] = 6] = "Analyzed";
+    ERPComplianceLawState[ERPComplianceLawState["Abrogated"] = 7] = "Abrogated";
+    ERPComplianceLawState[ERPComplianceLawState["Applicable"] = 8] = "Applicable";
+    ERPComplianceLawState[ERPComplianceLawState["Aknowledged"] = 9] = "Aknowledged";
+})(ERPComplianceLawState || (ERPComplianceLawState = {}));
+var ERPComplianceLawOrigin;
+(function (ERPComplianceLawOrigin) {
+    ERPComplianceLawOrigin[ERPComplianceLawOrigin["National"] = 1] = "National";
+    ERPComplianceLawOrigin[ERPComplianceLawOrigin["EU"] = 2] = "EU";
+    ERPComplianceLawOrigin[ERPComplianceLawOrigin["Regional"] = 3] = "Regional";
+    ERPComplianceLawOrigin[ERPComplianceLawOrigin["Local"] = 4] = "Local";
+    ERPComplianceLawOrigin[ERPComplianceLawOrigin["Technical"] = 5] = "Technical";
+    ERPComplianceLawOrigin[ERPComplianceLawOrigin["Voulontary"] = 6] = "Voulontary";
+    ERPComplianceLawOrigin[ERPComplianceLawOrigin["Internal"] = 7] = "Internal";
+    ERPComplianceLawOrigin[ERPComplianceLawOrigin["Other"] = 8] = "Other";
+})(ERPComplianceLawOrigin || (ERPComplianceLawOrigin = {}));
+const LawStates = [
+    { name: 'Applicabile', value: ERPComplianceLawState.Applicable },
+    { name: 'Da conoscere', value: ERPComplianceLawState.Aknowledged },
+    {
+        name: 'Applicabile / da conoscere',
+        value: ERPComplianceLawState.ApplicableOrAknowledged,
+    },
+    { name: 'Non applicabile', value: ERPComplianceLawState.NotApplicable },
+    { name: 'Abrogata', value: ERPComplianceLawState.Abrogated },
+    { name: 'Analizzata', value: ERPComplianceLawState.Analyzed },
+    { name: 'Da definire', value: ERPComplianceLawState.NotAnalyzed },
+    { name: 'In ritardo', value: ERPComplianceLawState.ExpiredAnalysis },
+    {
+        name: 'Con aggiornamenti pendenti',
+        value: ERPComplianceLawState.UpdatedLaws,
+    },
+];
+const LawOrigins = [
+    { name: 'Nazionale', value: ERPComplianceLawOrigin.National },
+    { name: 'Comunitaria', value: ERPComplianceLawOrigin.EU },
+    { name: 'Regionale', value: ERPComplianceLawOrigin.Regional },
+    { name: 'Locale', value: ERPComplianceLawOrigin.Local },
+    { name: 'Tecnica', value: ERPComplianceLawOrigin.Technical },
+    { name: 'Interna', value: ERPComplianceLawOrigin.Internal },
+    { name: 'Volontaria', value: ERPComplianceLawOrigin.Voulontary },
+    { name: 'Altro', value: ERPComplianceLawOrigin.Other },
+];
+const LawChangeStates = [
+    { name: 'Aperto', value: 1 },
+    { name: 'Chiuso', value: 2 },
+];
+var ERPComplianceActivityState;
+(function (ERPComplianceActivityState) {
+    ERPComplianceActivityState[ERPComplianceActivityState["NotPlanned"] = 128] = "NotPlanned";
+    ERPComplianceActivityState[ERPComplianceActivityState["Closed"] = 4] = "Closed";
+    ERPComplianceActivityState[ERPComplianceActivityState["Expired"] = 8] = "Expired";
+    ERPComplianceActivityState[ERPComplianceActivityState["Planned"] = 256] = "Planned";
+    ERPComplianceActivityState[ERPComplianceActivityState["Cancelled"] = 512] = "Cancelled";
+    ERPComplianceActivityState[ERPComplianceActivityState["UpdatedLaws"] = 1024] = "UpdatedLaws";
+    ERPComplianceActivityState[ERPComplianceActivityState["AlreadyManaged"] = 2048] = "AlreadyManaged";
+})(ERPComplianceActivityState || (ERPComplianceActivityState = {}));
+const ActivityStates = [
+    {
+        name: 'Da definire',
+        value: ERPComplianceActivityState.NotPlanned,
+    },
+    {
+        name: 'Pianificata',
+        value: ERPComplianceActivityState.Planned,
+    },
+    {
+        name: 'Chiusa',
+        value: ERPComplianceActivityState.Closed,
+    },
+    {
+        name: 'In ritardo',
+        value: ERPComplianceActivityState.Expired,
+    },
+    {
+        name: 'Annullata',
+        value: ERPComplianceActivityState.Cancelled,
+    },
+    {
+        name: 'Gestita separatamente',
+        value: ERPComplianceActivityState.AlreadyManaged,
+    },
+    {
+        name: 'Con aggiornamenti pendenti',
+        value: ERPComplianceActivityState.UpdatedLaws,
+    },
+];
+const ObligationTypes = [
+    { name: 'Autorizzazione', value: 1 },
+    { name: 'Verifiche periodiche manutentive', value: 2 },
+    { name: 'Misure organizzative', value: 3 },
+    { name: 'Controlli e misurazioni', value: 4 },
+    { name: 'Entrata in vigore', value: 5 },
+    { name: 'Documenti aziendali obbligatori', value: 6 },
+    {
+        name: 'Altri adempimenti formali (comunicazioni, dichiarazioni, ecc...)',
+        value: 7,
+    },
+    { name: 'Altro', value: 99 },
+];
+const ObligationAuthorities = [
+    { name: 'Agenzia ECHA', value: 1 },
+    { name: 'Albo Nazionale dei Gestori Ambientali', value: 2 },
+    { name: 'ARPA', value: 4 },
+    { name: 'ASL', value: 5 },
+    { name: 'Camera di Commercio', value: 8 },
+    { name: 'Comando provinciale dei Vigili del Fuoco', value: 10 },
+    { name: 'Comune', value: 13 },
+    { name: 'Consorzi gestione rifiuti particolari', value: 14 },
+    { name: 'Gestore del servizio', value: 21 },
+    { name: 'Gestore della rete di trasmissione nazionale', value: 22 },
+    { name: 'INAIL - IPSEMA - ISPESL', value: 23 },
+    { name: 'ISPRA', value: 26 },
+    { name: 'Ministero', value: 27 },
+    { name: 'Genio civile', value: 30 },
+    { name: 'Organo di vigilanza competente', value: 31 },
+    { name: 'Provincia', value: 33 },
+    { name: 'Regione', value: 35 },
+    { name: 'Uffici tecnici di finanza', value: 36 },
+    { name: 'Ispettorato del lavoro', value: 37 },
+    { name: 'Comitato Regionale Tecnico VF', value: 38 },
+    { name: 'Prefetto', value: 39 },
+    { name: 'Organismo notificato', value: 40 },
+    { name: 'Città Metropolitana', value: 41 },
+    { name: 'Nessuna', value: 28 },
+    { name: 'Altro', value: 3 }
+];
+var ERPRecurrenceFrequencyType;
+(function (ERPRecurrenceFrequencyType) {
+    ERPRecurrenceFrequencyType[ERPRecurrenceFrequencyType["Day"] = 1] = "Day";
+    ERPRecurrenceFrequencyType[ERPRecurrenceFrequencyType["Month"] = 2] = "Month";
+    ERPRecurrenceFrequencyType[ERPRecurrenceFrequencyType["Year"] = 3] = "Year";
+})(ERPRecurrenceFrequencyType || (ERPRecurrenceFrequencyType = {}));
+const RecurrenceFrequencyTypes = [
+    { name: 'Anni', value: ERPRecurrenceFrequencyType.Year },
+    { name: 'Mesi', value: ERPRecurrenceFrequencyType.Month },
+    { name: 'Giorni', value: ERPRecurrenceFrequencyType.Day },
+];
+
+class EvolutionService {
+    constructor() {
+        this.httpClient = inject(HttpClient);
+        this.broadcastService = inject(BroadcastService);
+        this.broadcastServiceSubscription = null;
+        this.dialogService = inject(DialogService);
+        this._serviceUri = null;
+        this._loginInfo = null;
+        this.loggedIn = signal(false);
+        this.loggingIn = signal(false);
+    }
+    get serviceUri() {
+        return this._serviceUri;
+    }
+    get loginInfo() {
+        if (!this._loginInfo) {
+            const loginInfo = localStorage.getItem('clipper_login_evolution');
+            if (loginInfo) {
+                try {
+                    this._loginInfo = JSON.parse(loginInfo);
+                }
+                catch { }
+            }
+        }
+        return this._loginInfo;
+    }
+    ngOnDestroy() {
+        if (this.broadcastServiceSubscription) {
+            this.broadcastServiceSubscription.unsubscribe();
+        }
+    }
+    /**
+     * Initialize service
+     * @param serviceUri : the service uri
+     */
+    initialize(serviceUri) {
+        // Create unique client id
+        if (!localStorage.getItem('evolution_client_id')) {
+            localStorage.setItem('evolution_client_id', SystemUtils.generateUUID());
+        }
+        // Initialize
+        this._serviceUri = serviceUri;
+        // React to message broadcasting
+        if (!this.broadcastServiceSubscription) {
+            this.broadcastServiceSubscription = this.broadcastService.getMessage().subscribe((message) => {
+                if (message.id === EvolutionMessages.LOGIN_CHANGED) {
+                    setTimeout(() => {
+                        this.login(message.data.email, message.data.password, true, message.data.oauth, message.data.oauthAccessToken).subscribe((r) => {
+                            if (!r.success)
+                                this.dialogService.error(r.message, null, "Errore di Evolution");
+                            else {
+                                this.dialogService.toast('Connesso a Evolution', 1500, 'power');
+                            }
+                        });
+                    }, 500);
+                }
+                else if (message.id === EvolutionMessages.LOGOUT_COMPLETED) {
+                    if (this.loggedIn()) {
+                        this.logout().subscribe((r) => {
+                            if (!r.success) {
+                                this.dialogService.error("<p>" + r.message + "</p><br><br><hr><p class='small'><i>Per eliminare la configurazione di Evolution accedere a:<br><b>menu > personalizza > collegamenti</b></i></p>", null, "Errore di Evolution");
+                            }
+                            else {
+                                this.dialogService.toast('Disconnesso da Evolution', 1500, 'power_off');
+                            }
+                        });
+                    }
+                }
+            });
+        }
+        // Eveluate current session storage in case of page refresh (F5)
+        if (!this.loggedIn() && this.getToken()) {
+            // Auto login
+            this.loggedIn.set(true);
+            // Notify
+            this.broadcastService.sendMessage(EvolutionMessages.LOGIN_COMPLETED);
+        }
+    }
+    /**
+  * Set JWT token
+  * @param value : the login result
+  */
+    setToken(value) {
+        sessionStorage.setItem('evolution_jwt', value.token);
+        sessionStorage.setItem('evolution_jwt_refresh', value.refreshToken ?? '');
+    }
+    /**
+     * Return current JWT token
+     * @param refresh: true to get the refresh token. Default is false.
+     */
+    getToken(refresh = false) {
+        let token = sessionStorage.getItem(refresh ? 'evolution_jwt_refresh' : 'evolution_jwt');
+        if (token && token[0] === '"') {
+            return token.substring(1, token.length - 1);
+        }
+        return token ?? '';
+    }
+    /**
+     * Perform login
+     * @param email: the optioanl email if using OAuth2
+     * @parma password: the optional password if using OAuth2
+     * @param remember: remember credentials
+     * @param oauth: the optional open authentication supported
+     * @param oauthAccessToken: the optional OAuth2 access token
+     * @returns: the login result
+     */
+    login(email = null, password = null, remember = false, oauth = null, oauthAccessToken = null) {
+        this.clear();
+        this.loggingIn.set(true);
+        return this.httpClient
+            .post(this._serviceUri + '/login2', {
+            user: oauth ? null : email,
+            password: oauth ? null : password,
+            clientId: localStorage.getItem("evolution_client_id"),
+            OAUTH: oauth
+        }, {
+            headers: !oauth
+                ? new HttpHeaders()
+                : new HttpHeaders()
+                    .set("Authorization", oauthAccessToken ?? '')
+        })
+            .pipe(catchError(err => {
+            this.handleLoginError();
+            return throwError(() => err);
+        }), map((r) => {
+            this.loggingIn.set(false);
+            if (r.success) {
+                // Store access token
+                this.setToken(r.value);
+                const loginInfo = {
+                    context: r.value.context,
+                    OAUTH: oauth
+                };
+                if (!oauth) {
+                    loginInfo.userCredentials =
+                        SystemUtils.cipher(JSON.stringify({
+                            email: email,
+                            password: password,
+                            remember: remember,
+                        }), loginInfo.context.userId.toString());
+                }
+                // Update info
+                localStorage.setItem('evolution_login', JSON.stringify(loginInfo));
+                this._loginInfo = loginInfo;
+                this.loggedIn.set(true);
+                // Notify
+                this.broadcastService.sendMessage(EvolutionMessages.LOGIN_COMPLETED);
+            }
+            return r;
+        }));
+    }
+    /**
+     * Perform logout
+     */
+    logout() {
+        return this.httpClient.post(this._serviceUri + '/logout', {}).pipe(map(r => {
+            this.clear();
+            return r;
+        }), catchError((_e) => {
+            this.clear();
+            return of([]);
+        }));
+    }
+    /**
+    * Switch the current login to a new one with the same credentials except role possibly (context change)
+    * @param id : new user id
+    */
+    loginSwitch(id) {
+        return this.httpClient
+            .post(this._serviceUri + '/login-switch/', {
+            userId: id,
+            clientId: localStorage.getItem("evolution_client_id")
+        })
+            .pipe(catchError((err) => {
+            this.handleLoginError();
+            return throwError(() => err);
+        }), map((r) => {
+            this.loggingIn.set(false);
+            if (r.success) {
+                // Store access token
+                this.setToken(r.value);
+                this._loginInfo = r.value.context;
+                this.loggedIn.set(true);
+                // Notify
+                this.broadcastService.sendMessage(EvolutionMessages.LOGIN_COMPLETED);
+            }
+            return r;
+        }));
+    }
+    /**
+   * Handle login error
+   */
+    handleLoginError() {
+        this.loggingIn.set(false);
+        localStorage.removeItem('evolution_login');
+    }
+    /**
+     * Reset login refresh timer and login state
+     */
+    reset() {
+        // Clear login info
+        this._loginInfo = null;
+        // Logged out
+        this.loggedIn.set(false);
+        // Notify
+        this.broadcastService.sendMessage(EvolutionMessages.LOGOUT_COMPLETED);
+    }
+    /**
+     * Clear login data
+     */
+    clear() {
+        // Clear local storage
+        sessionStorage.removeItem('evolution_jwt');
+        sessionStorage.removeItem('evolution_jwt_refresh');
+        sessionStorage.removeItem('evolution_oauth');
+        localStorage.removeItem('evolution_login');
+        // Reset login
+        this.reset();
+    }
+    /**
+   * Perform token refresh
+   */
+    refresh() {
+        return this.httpClient.get(this._serviceUri + '/refresh2/?token=' + this.getToken(true)).pipe(map((r) => {
+            // Update token
+            this.setToken(r.value);
+        }));
+    }
+    /**
+     * Convert folders in a tree of Node object.
+     * @param folders : the subfolders group or null to root
+     */
+    toNodes(folders) {
+        return this._toNodes(folders, null);
+    }
+    /**
+     * Convert folders in a tree of Node object.
+     * @param folders : the children group or null to root
+     */
+    _toNodes(folders, parent) {
+        let nodes = [];
+        folders.forEach((n) => {
+            let node = {
+                id: n.id,
+                name: n.name,
+                count: n.count,
+                parent: parent,
+                children: null,
+                bag: n,
+            };
+            node.children =
+                n.children && n.children.length > 0
+                    ? this._toNodes(n.children, node)
+                    : [];
+            nodes.push(node);
+        });
+        return nodes;
+    }
+    /**
+     * Retrieve the taxonomy
+     */
+    getTaxonomy() {
+        return this.httpClient.get(this._serviceUri + '/taxonomy');
+    }
+    /**
+     * Retrieve authorities
+     */
+    getAuthorities() {
+        return this.httpClient.get(this._serviceUri + '/compliance/authorities');
+    }
+    ////
+    // CONTEXT
+    ////
+    /**
+     * Change context
+     */
+    changeContext(params) {
+        return this.httpClient.post(this._serviceUri + '/compliance/context', params);
+    }
+    ////
+    // REGISTERS
+    ////
+    /**
+     * Retrieve a register
+     * @param id the register id
+     */
+    getRegister(id) {
+        return this.httpClient.get(this._serviceUri +
+            '/compliance/registers/' + id);
+    }
+    /**
+     * Collect register profiles
+     * @param params parameters
+     */
+    collectRegisterProfiles(params) {
+        return this.httpClient.post(this._serviceUri +
+            '/compliance/registers/profiles/collect', params);
+    }
+    ////
+    // LAWS
+    ////
+    /**
+     * Add one or more laws
+     * @param params parameters
+     */
+    addLaws(params) {
+        return this.httpClient.post(this._serviceUri + '/compliance/laws/add', params);
+    }
+    ////
+    // ACTIVITIES
+    ////
+    /**
+     * Retrieve activity groups
+     * @param group the group number
+     * @param site the site id
+     */
+    getGroups(group = 1, site = null) {
+        return this.httpClient.get(this._serviceUri +
+            (site
+                ? '/compliance/groups/?group=' +
+                    group +
+                    '&site=' +
+                    site
+                : '/compliance/groups/?group=' + group));
+    }
+    /**
+     * Add one or more activities
+     * @param params parameters
+     */
+    addActivities(params) {
+        return this.httpClient.post(this._serviceUri + '/compliance/activities/add', params);
+    }
+    /**
+   * Export laws
+   * @param params parameters
+   */
+    exportLaws(params) {
+        return this.httpClient.post(this._serviceUri + '/compliance/laws/export', params, { responseType: 'blob' });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: EvolutionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: EvolutionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: EvolutionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class EvolutionAuthInterceptor {
+    constructor() {
+        this.evolutionService = inject(EvolutionService);
+        this.broadcastService = inject(BroadcastService);
+        this.dialogService = inject(DialogService);
+        this.lastErrorTime = -1;
+    }
+    intercept(request, next) {
+        if (request.url.startsWith(this.evolutionService.serviceUri)) {
+            request = request.clone({ withCredentials: true });
+            return next.handle(this.addTokenToRequest(request))
+                .pipe(catchError$1(error => {
+                this.dialogService.clearBusy();
+                if (error instanceof HttpErrorResponse &&
+                    !request.url.includes("/login") &&
+                    error.status === 401) {
+                    return this.handle401Error(request, next);
+                }
+                const errorTime = new Date().getTime();
+                if (errorTime - this.lastErrorTime > 5000) {
+                    this.lastErrorTime = errorTime;
+                    const invalidSession = error.status == "403";
+                    this.dialogService.error("<p>" + (error.error?.message ?? error.message ?? "Impossibile eseguire l'operazione richiesta.").replaceAll("\r\n", "</p><p>") + "</p>", null, "Errore in Clipper", undefined, undefined, invalidSession ? 5000 : 15000).afterClosed().subscribe(() => {
+                        if (invalidSession) {
+                            this.broadcastService.sendMessage(EvolutionMessages.LOGOUT);
+                        }
+                    });
+                }
+                return throwError(() => error);
+            }));
+        }
+        return next.handle(request);
+    }
+    /**
+     * Handle 401 error
+     * @param request : the request
+     * @param next : the http handler
+     */
+    handle401Error(request, next) {
+        if (this.evolutionService.loggedIn()) {
+            return this.evolutionService.refresh().pipe(switchMap(() => {
+                return next.handle(this.addTokenToRequest(request));
+            }), catchError$1(error => {
+                return throwError(() => error);
+            }));
+        }
+        return next.handle(request);
+    }
+    /**
+     * Add token to request
+     * @param request : the request
+     * @param token: the token or null to use curre3nt
+     */
+    addTokenToRequest(request, token = null) {
+        if (request.url.startsWith(this.evolutionService.serviceUri)) {
+            if (!token)
+                token = this.evolutionService.getToken();
+            if (token) {
+                return request.clone({
+                    setHeaders: {
+                        Authorization: 'Bearer ' + token,
+                        'ngsw-bypass': 'ngsw-bypass'
+                    },
+                });
+            }
+        }
+        return request;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: EvolutionAuthInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: EvolutionAuthInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: EvolutionAuthInterceptor, decorators: [{
+            type: Injectable
+        }] });
+
+class EvolutionCommonModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: EvolutionCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.1", ngImport: i0, type: EvolutionCommonModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: EvolutionCommonModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.1", ngImport: i0, type: EvolutionCommonModule, decorators: [{
+            type: NgModule
+        }] });
+
+/*
+ * Public API Surface of ars-utils
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActivityStates, ERPComplianceActivityState, ERPComplianceLawOrigin, ERPComplianceLawState, ERPComplianceLawsSelectionType, ERPComplianceNotificationLimit, ERPComplianceProfileFlags, ERPComplianceProfileRole, ERPComplianceRegisterNotificationType, ERPComplianceRegisterSiteImportOptions, ERPComplianceScope, ERPRecurrenceFrequencyType, EvolutionAuthInterceptor, EvolutionCommonModule, EvolutionMessages, EvolutionService, LawChangeStates, LawOrigins, LawStates, NotificationLimits, Notifications, ObligationAuthorities, ObligationTypes, ProfileFlags, ProfileRoles, RecurrenceFrequencyTypes, Scopes };
+//# sourceMappingURL=arsedizioni-ars-utils-evolution.common.mjs.map