intelica-library-components 1.1.18 → 1.1.22

package/fesm2022/intelica-library-components.mjs

@@ -1,8 +1,9 @@
 import * as i0 from '@angular/core';
 import { inject, Injectable, signal, Pipe, Component, TemplateRef, ContentChild, Input, Directive, EventEmitter, ContentChildren, Output, HostListener, forwardRef, ViewChild, PLATFORM_ID, Inject, output, Optional, Host } from '@angular/core';
 import { getCookie, Cookies, setCookie } from 'typescript-cookie';
+import * as i1$4 from '@angular/common/http';
 import { HttpClient, HttpHeaders } from '@angular/common/http';
-import { BehaviorSubject, catchError, throwError, from, switchMap, Subject, Subscription, of, delay, tap, map } from 'rxjs';
+import { BehaviorSubject, catchError, throwError, from, switchMap, Subject, Subscription, of, delay, tap, map, firstValueFrom } from 'rxjs';
 import Swal from 'sweetalert2';
 import * as i1 from '@angular/common';
 import { DatePipe, CommonModule, NgIf, isPlatformBrowser, NgClass } from '@angular/common';
@@ -56,6 +57,7 @@ import JSEncrypt from 'jsencrypt';
 import { Guid } from 'guid-typescript';
 import Aura from '@primeng/themes/aura';
 import { definePreset } from '@primeng/themes';
+import * as signalR from '@microsoft/signalr';
 
 class ConfigService {
     Http = inject(HttpClient);
@@ -10386,11 +10388,569 @@ const IntelicaTheme = definePreset(Aura, {
     },
 });
 
+// notification/dto/recipient-dispatch-error.dto.ts
+
+class NotificationService {
+    http;
+    configService = inject(ConfigService);
+    path = `${this.configService.environment?.notificationsPath}/Notifications`;
+    defaultHeaders = new HttpHeaders({
+        refreshtoken: "f06c110a-ea4e-44a9-896f-210f3b387e57",
+        languagecode: "EN",
+        pageRoot: "",
+        authorization: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwcmVmZXJyZWRfdXNlcm5hbWUiOiJBbGV4YW5kZXIiLCJmdWxsTmFtZSI6IkFsZXhhbmRlciBUb3JyZSIsInN1YiI6Ijg3ZTQxYzZlLWNmN2EtNDk4MC05YTQ1LThjZjllNWMwOGMzZCIsImVtYWlsIjoiam9oYW4uY2FyYm9uZWxAaW50ZWxpY2EuY29tIiwiYnVzaW5lc3NVc2VyQ2xpZW50R3JvdXBJRCI6ImNlMjE5NDAyLWQyMDAtNGU1Yy1iNzE0LWJkNDJiMjZhNzNkNSIsImJhbmtzSUQiOiJnUlZPUEt6V3BNbHQ2NFE3OWdDcUxlQ1pFeWp2RjVFQVo0TmNMVTQvZlhJMVlvbERPeEFOV0NWTUpFYkJYRDJQUHkvUi8xdDVQVHBFZ08vcFFPcnMwVnNNeWRONkVocEY5MzRCRDJFRXhlelVyakZWWVduWitrcCtObGRLOU56VWg4VjZaRjBVTzEyN0JIaG12aGhUNzZMRm51Zm9nSndUTHVuOW5qMFpEaSsxV3MxTHkzZytzWkNYSVdTelR3QjBEc1g5Y2tXSTJrWmFHeWhHVlFhTlliT3hGYzU5UU9xV0pxQUJqdmVBdFNEaGNQdFZta3RIOXFaaEJ5Tkphdkh5R1pkWWJScXovcUZPOW1HUC92NjVScFZ5djNwejhCZUtvMVlJVW5vSUFqSU9udzRTMEkzcmxaSTNrTExBRFFOdnhBSk81NjgvZTVvdWlVZFd3SDlJd2c9PSIsImlzSW50ZWxpY2EiOiIxIiwiY2xpZW50R3JvdXBJRCI6ImU5ZDc1ODY3LTZkMDQtNGNiMC1iZjMxLTE5MmI5Y2VjMzVkYSIsImNsaWVudElEIjoiMDYzMGU0MDEtMzk1Ny00OTU5LTljYTUtYjM1MGVkNmU5Yjk2IiwiYm5rR3JvdXBJRCI6IjAiLCJpbXJwUHJvamVjdElEIjoiMTAwNjMyIiwiZXhwIjoxNzY4ODU3MTUwLCJpc3MiOiJpbnRlbGljYS5jb20iLCJhdWQiOiJpbnRlbGljYS5jb20ifQ.n0BGAUHrp6BiA_XpgTw6WdresOk_C3aaON7V7AcF5uo",
+    });
+    constructor(http) {
+        this.http = http;
+    }
+    getNotificacionsByUser(userId) {
+        return this.http.get(`${this.path}/users/${encodeURIComponent(userId)}`, { headers: this.defaultHeaders });
+    }
+    markAsRead(recipientId) {
+        return this.http.post(`${this.path}/users/recipients/${recipientId}/read`, {}, { headers: this.defaultHeaders });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationService, deps: [{ token: i1$4.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1$4.HttpClient }] });
+
+class NotificationJobService {
+    http;
+    configService = inject(ConfigService);
+    path = `${this.configService.environment?.notificationsPath}/NotificationJobs`;
+    defaultHeaders = new HttpHeaders({
+        refreshtoken: "f06c110a-ea4e-44a9-896f-210f3b387e57",
+        languagecode: "EN",
+        pageRoot: "",
+        authorization: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwcmVmZXJyZWRfdXNlcm5hbWUiOiJBbGV4YW5kZXIiLCJmdWxsTmFtZSI6IkFsZXhhbmRlciBUb3JyZSIsInN1YiI6Ijg3ZTQxYzZlLWNmN2EtNDk4MC05YTQ1LThjZjllNWMwOGMzZCIsImVtYWlsIjoiam9oYW4uY2FyYm9uZWxAaW50ZWxpY2EuY29tIiwiYnVzaW5lc3NVc2VyQ2xpZW50R3JvdXBJRCI6ImNlMjE5NDAyLWQyMDAtNGU1Yy1iNzE0LWJkNDJiMjZhNzNkNSIsImJhbmtzSUQiOiJnUlZPUEt6V3BNbHQ2NFE3OWdDcUxlQ1pFeWp2RjVFQVo0TmNMVTQvZlhJMVlvbERPeEFOV0NWTUpFYkJYRDJQUHkvUi8xdDVQVHBFZ08vcFFPcnMwVnNNeWRONkVocEY5MzRCRDJFRXhlelVyakZWWVduWitrcCtObGRLOU56VWg4VjZaRjBVTzEyN0JIaG12aGhUNzZMRm51Zm9nSndUTHVuOW5qMFpEaSsxV3MxTHkzZytzWkNYSVdTelR3QjBEc1g5Y2tXSTJrWmFHeWhHVlFhTlliT3hGYzU5UU9xV0pxQUJqdmVBdFNEaGNQdFZta3RIOXFaaEJ5Tkphdkh5R1pkWWJScXovcUZPOW1HUC92NjVScFZ5djNwejhCZUtvMVlJVW5vSUFqSU9udzRTMEkzcmxaSTNrTExBRFFOdnhBSk81NjgvZTVvdWlVZFd3SDlJd2c9PSIsImlzSW50ZWxpY2EiOiIxIiwiY2xpZW50R3JvdXBJRCI6ImU5ZDc1ODY3LTZkMDQtNGNiMC1iZjMxLTE5MmI5Y2VjMzVkYSIsImNsaWVudElEIjoiMDYzMGU0MDEtMzk1Ny00OTU5LTljYTUtYjM1MGVkNmU5Yjk2IiwiYm5rR3JvdXBJRCI6IjAiLCJpbXJwUHJvamVjdElEIjoiMTAwNjMyIiwiZXhwIjoxNzY4ODU3MTUwLCJpc3MiOiJpbnRlbGljYS5jb20iLCJhdWQiOiJpbnRlbGljYS5jb20ifQ.n0BGAUHrp6BiA_XpgTw6WdresOk_C3aaON7V7AcF5uo",
+    });
+    constructor(http) {
+        this.http = http;
+    }
+    createJobNotifications(payload) {
+        return this.http.post(`${this.path}/notifications`, payload, {
+            headers: this.defaultHeaders,
+        });
+    }
+    createJob(payload) {
+        return this.http.post(`${this.path}`, payload, {
+            headers: this.defaultHeaders,
+        });
+    }
+    getJob(jobId) {
+        return this.http.get(`${this.path}/${jobId}`);
+    }
+    createNotifications(jobId, payload) {
+        return this.http.post(`${this.path}/${jobId}/notifications`, payload, { headers: this.defaultHeaders });
+    }
+    getActiveJob(featureCode, origin) {
+        let url = `${this.path}/active?featureCode=${encodeURIComponent(featureCode)}`;
+        if (origin) {
+            url += `&origin=${encodeURIComponent(origin)}`;
+        }
+        return this.http.get(url, { headers: this.defaultHeaders }).pipe(map(list => (Array.isArray(list) && list.length > 0 ? list[0] : null)), catchError(err => {
+            console.error("Error obteniendo active jobs", err);
+            return of(null);
+        }));
+    }
+    getRecipients(jobId) {
+        return this.http.get(`${this.path}/${jobId}/recipients`, { headers: this.defaultHeaders });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationJobService, deps: [{ token: i1$4.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationJobService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationJobService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i1$4.HttpClient }] });
+
+class NotificationSignalRService {
+    zone;
+    configService = inject(ConfigService);
+    path = `${this.configService.environment?.signalPath}/websocket`;
+    hubConnection;
+    startPromise;
+    // Mantiene los grupos a los que ya nos unimos (idempotencia + rejoin tras reconexión)
+    joinedGroups = new Set();
+    notificationSendSubject = new Subject();
+    notificationSend$ = this.notificationSendSubject.asObservable();
+    jobProgressSubject = new Subject();
+    jobProgress$ = this.jobProgressSubject.asObservable();
+    callbackResultSubject = new Subject();
+    callbackResult$ = this.callbackResultSubject.asObservable();
+    constructor(zone) {
+        this.zone = zone;
+    }
+    /**
+     * Inicia la conexión una sola vez. Reutiliza la promesa para evitar carreras.
+     */
+    startConnection() {
+        if (this.startPromise)
+            return this.startPromise;
+        this.hubConnection = new signalR.HubConnectionBuilder().withUrl(this.path).withAutomaticReconnect().build();
+        this.registerListeners();
+        this.registerReconnectHandlers();
+        this.startPromise = this.hubConnection.start().catch(err => {
+            console.error("Error starting SignalR connection", err);
+            this.startPromise = undefined; // permitir reintentar
+            throw err;
+        });
+        return this.startPromise;
+    }
+    /**
+     * Se une a un grupo de forma idempotente.
+     * Importante: esta función garantiza que la conexión esté iniciada.
+     */
+    async joinScope(scopeType, scopeId) {
+        await this.startConnection();
+        if (!this.hubConnection)
+            return;
+        const groupName = `${scopeType}-${scopeId}`;
+        if (this.joinedGroups.has(groupName))
+            return;
+        await this.hubConnection.invoke("Connect", groupName);
+        this.joinedGroups.add(groupName);
+    }
+    /**
+     * Sale de un grupo y actualiza el estado local.
+     * Requiere que el Hub implemente el método Disconnect(groupName).
+     */
+    async leaveScope(scopeType, scopeId) {
+        if (!this.hubConnection)
+            return;
+        const groupName = `${scopeType}-${scopeId}`;
+        if (!this.joinedGroups.has(groupName))
+            return;
+        await this.hubConnection.invoke("Disconnect", groupName);
+        this.joinedGroups.delete(groupName);
+    }
+    /**
+     * Detiene la conexión y limpia estado local.
+     * Útil si quieres liberar recursos al cerrar sesión.
+     */
+    async stopConnection() {
+        if (!this.hubConnection)
+            return;
+        try {
+            await this.hubConnection.stop();
+        }
+        finally {
+            this.joinedGroups.clear();
+            this.hubConnection = undefined;
+            this.startPromise = undefined;
+        }
+    }
+    registerListeners() {
+        if (!this.hubConnection)
+            return;
+        this.hubConnection.on("NotificationSend", (raw) => {
+            this.zone.run(() => {
+                const data = JSON.parse(raw);
+                this.notificationSendSubject.next(data);
+            });
+        });
+        this.hubConnection.on("JobProgress", (raw) => {
+            this.zone.run(() => {
+                const data = JSON.parse(raw);
+                this.jobProgressSubject.next(data);
+            });
+        });
+        this.hubConnection.on("CallbackResult", (raw) => {
+            this.zone.run(() => {
+                const data = JSON.parse(raw);
+                this.callbackResultSubject.next(data);
+            });
+        });
+        // Opcional (tu hub lo emite): útil para debugging
+        this.hubConnection.on("Connect", (_msg) => { });
+    }
+    /**
+     * SignalR pierde pertenencia a grupos tras reconexión: re-join automático.
+     */
+    registerReconnectHandlers() {
+        if (!this.hubConnection)
+            return;
+        this.hubConnection.onreconnected(async () => {
+            try {
+                for (const groupName of this.joinedGroups) {
+                    await this.hubConnection.invoke("Connect", groupName);
+                }
+            }
+            catch (e) {
+                console.error("Error rejoining groups after reconnection", e);
+            }
+        });
+        this.hubConnection.onclose(() => {
+            // Mantén joinedGroups para poder rejoin si el usuario vuelve a startConnection()
+            this.startPromise = undefined;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationSignalRService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationSignalRService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationSignalRService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: i0.NgZone }] });
+
+class NotificationOrchestratorService {
+    jobService;
+    notificationService;
+    signalR;
+    // Config actual (feature/origin) del “scope”
+    featureCode;
+    origin;
+    currentJobId;
+    subscribedJobId;
+    // --- streams públicos (feature/origin job state)
+    jobStateSubject = new BehaviorSubject({
+        status: "idle",
+        processedCount: 0,
+        totalCount: 0,
+        processedNotificationsCount: 0,
+        totalNotificationsCount: 0,
+    });
+    jobState$ = this.jobStateSubject.asObservable();
+    dispatchErrorsMapSubject = new BehaviorSubject(new Map());
+    dispatchErrors$ = this.dispatchErrorsMapSubject.asObservable();
+    callbackRawSubject = new Subject();
+    callbackRaw$ = this.callbackRawSubject.asObservable();
+    /**
+     * Router de progreso por jobId (para UIs multi-job).
+     */
+    jobProgressSubjects = new Map();
+    jobWatchRefCount = new Map();
+    /**
+     * Router de NotificationSend por userId (campana/inbox).
+     */
+    userInboxSubjects = new Map();
+    userWatchRefCount = new Map();
+    // Guard anti-carreras para rehidratación
+    initInFlight;
+    constructor(jobService, notificationService, signalR) {
+        this.jobService = jobService;
+        this.notificationService = notificationService;
+        this.signalR = signalR;
+        // stream global SignalR => orquestador enruta
+        this.signalR.jobProgress$.subscribe(update => this.onJobProgress(update));
+        this.signalR.callbackResult$.subscribe(update => this.onCallbackResult(update));
+        this.signalR.notificationSend$.subscribe(update => this.onNotificationSend(update));
+    }
+    // ---------------------------------------------------------------------
+    // API pública para UI: Inbox user-scoped (NotificationSend)
+    // ---------------------------------------------------------------------
+    async watchUserInbox(userId) {
+        if (!userId)
+            throw new Error("userId is required");
+        const current = this.userWatchRefCount.get(userId) ?? 0;
+        this.userWatchRefCount.set(userId, current + 1);
+        await this.signalR.joinScope("user", userId);
+        return this.userInbox$(userId);
+    }
+    async unwatchUserInbox(userId) {
+        if (!userId)
+            return;
+        const current = this.userWatchRefCount.get(userId) ?? 0;
+        if (current <= 1) {
+            this.userWatchRefCount.delete(userId);
+            await this.signalR.leaveScope("user", userId);
+            const subj = this.userInboxSubjects.get(userId);
+            if (subj) {
+                subj.complete();
+                this.userInboxSubjects.delete(userId);
+            }
+            return;
+        }
+        this.userWatchRefCount.set(userId, current - 1);
+    }
+    userInbox$(userId) {
+        let subj = this.userInboxSubjects.get(userId);
+        if (!subj) {
+            subj = new Subject();
+            this.userInboxSubjects.set(userId, subj);
+        }
+        return subj.asObservable();
+    }
+    // ---------------------------------------------------------------------
+    // API pública para UI: Job progress por jobId (PRG)
+    // ---------------------------------------------------------------------
+    async watchJobProgress(jobId) {
+        if (!jobId)
+            throw new Error("jobId is required");
+        const current = this.jobWatchRefCount.get(jobId) ?? 0;
+        this.jobWatchRefCount.set(jobId, current + 1);
+        await this.signalR.joinScope("job", jobId);
+        return this.jobProgress$(jobId);
+    }
+    async unwatchJobProgress(jobId) {
+        if (!jobId)
+            return;
+        const current = this.jobWatchRefCount.get(jobId) ?? 0;
+        if (current <= 1) {
+            this.jobWatchRefCount.delete(jobId);
+            await this.signalR.leaveScope("job", jobId);
+            const subj = this.jobProgressSubjects.get(jobId);
+            if (subj) {
+                subj.complete();
+                this.jobProgressSubjects.delete(jobId);
+            }
+            return;
+        }
+        this.jobWatchRefCount.set(jobId, current - 1);
+    }
+    jobProgress$(jobId) {
+        let subj = this.jobProgressSubjects.get(jobId);
+        if (!subj) {
+            subj = new Subject();
+            this.jobProgressSubjects.set(jobId, subj);
+        }
+        return subj.asObservable();
+    }
+    // ---------------------------------------------------------------------
+    // Scope feature/origin (tu lógica existente)
+    // ---------------------------------------------------------------------
+    rehydrateScope(featureCode, origin) {
+        this.featureCode = featureCode;
+        this.origin = origin;
+        if (this.initInFlight)
+            return this.initInFlight;
+        this.initInFlight = (async () => {
+            try {
+                await this.rehydrateActiveJobInternal();
+            }
+            finally {
+                this.initInFlight = undefined;
+            }
+        })();
+        return this.initInFlight;
+    }
+    getCurrentJobId() {
+        return this.currentJobId;
+    }
+    getJobStateSnapshot() {
+        return this.jobStateSubject.value;
+    }
+    async ensureActiveOrCreateJobNotifications(totalCount, totalNotificationsCount, notificationDraft) {
+        if (!this.featureCode || !this.origin)
+            throw new Error("Scope not initialized. Call rehydrateScope(featureCode, origin) first.");
+        if (this.currentJobId) {
+            return { jobId: this.currentJobId, mode: "active" };
+        }
+        const jobPayload = {
+            featureCode: this.featureCode,
+            origin: this.origin,
+            totalCount,
+            totalNotificationsCount,
+        };
+        const job = await firstValueFrom(this.jobService.createJob(jobPayload));
+        this.currentJobId = job.jobId;
+        this.setJobState({
+            jobId: this.currentJobId,
+            status: "pending",
+            processedCount: 0,
+            totalCount,
+            processedNotificationsCount: 0,
+            totalNotificationsCount,
+        });
+        await this.subscribeToJob(this.currentJobId);
+        const notifications = notificationDraft.map(draft => ({
+            originReference: `${draft.originReference}-${job.jobId}`,
+            notificationTypeCode: draft.notificationTypeCode,
+            destination: draft.destination,
+            destinationLabel: draft.destinationLabel,
+            bucketName: draft.bucketName,
+            templateName: draft.templateName,
+            templateData: draft.templateData,
+            priorityCode: draft.priorityCode,
+            title: draft.title,
+            body: draft.body,
+            metaData: draft.metaData,
+            recipients: draft.recipients,
+            actions: draft.actions,
+            callbacks: draft.callbacks,
+        }));
+        await firstValueFrom(this.jobService.createNotifications(job.jobId, notifications));
+        return { jobId: this.currentJobId, mode: "created" };
+    }
+    async ensureCreateJobNotifications(featureCode, origin, totalCount, totalNotificationsCount, notificationDraft) {
+        if (!featureCode || !origin)
+            throw new Error("Scope not initialized.");
+        const jobPayload = {
+            featureCode: featureCode,
+            origin: origin,
+            totalCount,
+            totalNotificationsCount,
+            notifications: notificationDraft.map(draft => ({
+                originReference: draft.originReference,
+                notificationTypeCode: draft.notificationTypeCode,
+                destination: draft.destination,
+                destinationLabel: draft.destinationLabel,
+                bucketName: draft.bucketName,
+                templateName: draft.templateName,
+                templateData: draft.templateData,
+                priorityCode: draft.priorityCode,
+                title: draft.title,
+                body: draft.body,
+                metaData: draft.metaData,
+                recipients: draft.recipients,
+                actions: draft.actions,
+            })),
+        };
+        await firstValueFrom(this.jobService.createJobNotifications(jobPayload));
+    }
+    async markAsRead(recipientId) {
+        const result = await firstValueFrom(this.notificationService.markAsRead(recipientId));
+        return result;
+    }
+    async getNotificacionsByUser(userId) {
+        const items = await firstValueFrom(this.notificationService.getNotificacionsByUser(userId));
+        return items;
+    }
+    resetLocal() {
+        this.currentJobId = undefined;
+        this.setJobState({ status: "idle", processedCount: 0, totalCount: 0, processedNotificationsCount: 0, totalNotificationsCount: 0 });
+        this.dispatchErrorsMapSubject.next(new Map());
+    }
+    async rehydrateActiveJobInternal() {
+        if (!this.featureCode || !this.origin)
+            return;
+        const active = await firstValueFrom(this.jobService.getActiveJob(this.featureCode, this.origin));
+        if (!active) {
+            this.currentJobId = undefined;
+            this.setJobState({ status: "idle", processedCount: 0, totalCount: 0, processedNotificationsCount: 0, totalNotificationsCount: 0 });
+            this.dispatchErrorsMapSubject.next(new Map());
+            return;
+        }
+        this.currentJobId = active.jobId;
+        this.setJobState({
+            jobId: active.jobId,
+            status: active.statusCode?.toLowerCase() || "running",
+            processedCount: active.processedCount ?? 0,
+            totalCount: active.totalCount ?? 0,
+            processedNotificationsCount: active.processedNotificationsCount ?? 0,
+            totalNotificationsCount: active.totalNotificationsCount ?? 0,
+        });
+        const recipients = await firstValueFrom(this.jobService.getRecipients(active.jobId));
+        const map = new Map();
+        for (const r of recipients) {
+            if (r.recipientId && r.statusCode === "failed") {
+                map.set(r.recipientId, {
+                    recipientId: r.recipientId,
+                    lastErrorMessage: r.lastErrorMessage ?? null,
+                    channelCode: r.channelCode || undefined,
+                    statusCode: r.statusCode,
+                    attempts: r.attempts,
+                    lastAttemptAt: r.lastAttemptAt ?? null,
+                    userId: r.userId ?? null,
+                    clientId: r.clientId ?? null,
+                    groupId: r.groupId ?? null,
+                });
+            }
+        }
+        this.dispatchErrorsMapSubject.next(map);
+        await this.subscribeToJob(active.jobId);
+    }
+    async subscribeToJob(jobId) {
+        if (this.subscribedJobId && this.subscribedJobId !== jobId) {
+            await this.signalR.leaveScope("job", this.subscribedJobId);
+            await this.signalR.leaveScope("callBack", this.subscribedJobId);
+        }
+        this.subscribedJobId = jobId;
+        await this.signalR.joinScope("job", jobId);
+        await this.signalR.joinScope("callBack", jobId);
+    }
+    onNotificationSend(update) {
+        // Enrutado por userId para campana/inbox
+        if (update.userId) {
+            this.userInboxSubjects.get(update.userId)?.next(update);
+        }
+    }
+    onJobProgress(update) {
+        // Enrutado por jobId para UIs multi-job
+        if (update.jobId) {
+            this.jobProgressSubjects.get(update.jobId)?.next(update);
+        }
+        // Lógica existente: solo aplica al job "actual" (feature/origin)
+        if (!this.currentJobId || update.jobId !== this.currentJobId)
+            return;
+        if (update.recipientId) {
+            const current = this.dispatchErrorsMapSubject.value;
+            const next = new Map(current);
+            if ((update.statusCode ?? "").toLowerCase() === "failed") {
+                next.set(update.recipientId, {
+                    recipientId: update.recipientId,
+                    lastErrorMessage: update.lastErrorMessage ?? null,
+                    notificationId: update.notificationId,
+                    jobId: update.jobId ?? null,
+                    channelCode: update.channelCode,
+                    statusCode: update.statusCode,
+                    attempts: update.attempts,
+                    lastAttemptAt: update.lastAttemptAt ?? null,
+                    userId: update.userId ?? null,
+                    clientId: update.clientId ?? null,
+                    groupId: update.groupId ?? null,
+                });
+            }
+            else {
+                next.delete(update.recipientId);
+            }
+            this.dispatchErrorsMapSubject.next(next);
+        }
+        if (typeof update.jobProcessedCount === "number" && typeof update.jobTotalCount === "number") {
+            this.setJobState({
+                jobId: this.currentJobId,
+                status: this.jobStateSubject.value.status,
+                processedCount: update.jobProcessedCount,
+                totalCount: update.jobTotalCount,
+                processedNotificationsCount: update.jobProcessedNotificationsCount,
+                totalNotificationsCount: update.jobTotalNotificationsCount,
+            });
+        }
+        if (update.jobStatusCode?.toLowerCase() === "completed") {
+            this.setJobState({
+                jobId: this.currentJobId,
+                status: "completed",
+                processedCount: this.jobStateSubject.value.processedCount,
+                totalCount: this.jobStateSubject.value.totalCount,
+                processedNotificationsCount: this.jobStateSubject.value.processedNotificationsCount,
+                totalNotificationsCount: this.jobStateSubject.value.totalNotificationsCount,
+            });
+        }
+        else if (this.jobStateSubject.value.status === "pending") {
+            this.setJobState({ ...this.jobStateSubject.value, status: "running" });
+        }
+    }
+    onCallbackResult(update) {
+        update.payload = update.payload ? JSON.parse(update.payload) : null;
+        update.responseBody = update.responseBody ? JSON.parse(update.responseBody) : null;
+        this.callbackRawSubject.next(update);
+    }
+    setJobState(state) {
+        this.jobStateSubject.next({
+            jobId: state.jobId,
+            status: state.status,
+            processedCount: state.processedCount,
+            totalCount: state.totalCount,
+            processedNotificationsCount: state.processedNotificationsCount,
+            totalNotificationsCount: state.totalNotificationsCount,
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationOrchestratorService, deps: [{ token: NotificationJobService }, { token: NotificationService }, { token: NotificationSignalRService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationOrchestratorService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.1", ngImport: i0, type: NotificationOrchestratorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: () => [{ type: NotificationJobService }, { type: NotificationService }, { type: NotificationSignalRService }] });
+
 //Pipes
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ALERT_DEFAULTS, ALERT_ICON_PATHS, ALERT_TYPE_CONFIG, ActionDirective, ActionsMenuComponent, AddFavoritesComponent, AlertButtonMode, AlertService, AlertType, ButtonSplitComponent, CheckboxFilterDirective, Color, ColumnComponent, ColumnGroupComponent, CompareByField, ConfigService, CookieAttributesGeneral, DATEPICKER_BUTTON_TYPES, DataDirective, DateFilterDirective, DateModeOptions, DatepickerComponent, DynamicInputValidation, EchartComponent, EchartService, ElementService, EmailInputValidation, ErrorInterceptor, FeatureFlagService, FilterChipsComponent, FiltersComponent, FormatAmountPipe, GetCookieAttributes, GlobalFeatureFlagService, GlobalTermService, HtmlToExcelService, InitializeConfigService, InputValidation, IntelicaAlertComponent, IntelicaCellCheckboxDirective, IntelicaSessionService, IntelicaTheme, ItemSplitDirective, LanguageService, MatrixColumnComponent, MatrixColumnGroupComponent, MatrixTableComponent, ModalDialogComponent, MultiSelectComponent, OrderConstants, PageRootChildGuard, PaginatorComponent, Patterns, PopoverComponent, ProfileService, RecordPerPageComponent, RefreshTokenInterceptor, RouteGuard, RowResumenComponent, RowResumenTreeComponent, SearchComponent, SelectDetailFilterDirective, SelectFilterDirective, SharedService, SkeletonChartComponent, SkeletonComponent, SkeletonService, SkeletonTableComponent, SortingComponent, SpinnerComponent, SpinnerService, SweetAlertService, TableComponent, TableFetchComponent, TableSortOrder, TemplateDirective, TemplateMenuComponent, TermGuard, TermPipe, TermService, TextAreaFilterDirective, TextFilterDirective, TextRangeFilterDirective, TreeColumnComponent, TreeColumnGroupComponent, TreeTableComponent, TruncatePipe, decryptData, encryptData, getColor };
+export { ALERT_DEFAULTS, ALERT_ICON_PATHS, ALERT_TYPE_CONFIG, ActionDirective, ActionsMenuComponent, AddFavoritesComponent, AlertButtonMode, AlertService, AlertType, ButtonSplitComponent, CheckboxFilterDirective, Color, ColumnComponent, ColumnGroupComponent, CompareByField, ConfigService, CookieAttributesGeneral, DATEPICKER_BUTTON_TYPES, DataDirective, DateFilterDirective, DateModeOptions, DatepickerComponent, DynamicInputValidation, EchartComponent, EchartService, ElementService, EmailInputValidation, ErrorInterceptor, FeatureFlagService, FilterChipsComponent, FiltersComponent, FormatAmountPipe, GetCookieAttributes, GlobalFeatureFlagService, GlobalTermService, HtmlToExcelService, InitializeConfigService, InputValidation, IntelicaAlertComponent, IntelicaCellCheckboxDirective, IntelicaSessionService, IntelicaTheme, ItemSplitDirective, LanguageService, MatrixColumnComponent, MatrixColumnGroupComponent, MatrixTableComponent, ModalDialogComponent, MultiSelectComponent, NotificationJobService, NotificationOrchestratorService, NotificationService, NotificationSignalRService, OrderConstants, PageRootChildGuard, PaginatorComponent, Patterns, PopoverComponent, ProfileService, RecordPerPageComponent, RefreshTokenInterceptor, RouteGuard, RowResumenComponent, RowResumenTreeComponent, SearchComponent, SelectDetailFilterDirective, SelectFilterDirective, SharedService, SkeletonChartComponent, SkeletonComponent, SkeletonService, SkeletonTableComponent, SortingComponent, SpinnerComponent, SpinnerService, SweetAlertService, TableComponent, TableFetchComponent, TableSortOrder, TemplateDirective, TemplateMenuComponent, TermGuard, TermPipe, TermService, TextAreaFilterDirective, TextFilterDirective, TextRangeFilterDirective, TreeColumnComponent, TreeColumnGroupComponent, TreeTableComponent, TruncatePipe, decryptData, encryptData, getColor };
 //# sourceMappingURL=intelica-library-components.mjs.map