HRM-10/HRM.UI/ClientApp/src/app/app.topbar.service.ts

363 lines
16 KiB
TypeScript
Raw Normal View History

2026-11-03 13:06:00 +06:00
import { Injectable, OnDestroy } from '@angular/core';
import { NavigationEnd, Router } from '@angular/router';
import { BehaviorSubject, Observable, Subject, Subscription, forkJoin, of } from 'rxjs';
import { catchError, distinctUntilChanged, filter, finalize, map, shareReplay, switchMap } from 'rxjs/operators';
import { JwtHelperService } from '@auth0/angular-jwt';
import { AuthService } from './_services/auth/auth.service';
import { WorkflowService } from './_services/workflow/workflow.service';
/**
* SINGLE SOURCE OF TRUTH for ESS notification state.
*
* - fetch -> ensureLoaded() / refreshNotifications()
* - state -> notifications$ (bell / panel list - "OtherNotifications")
* hrNotifications$ (dashboard "Company Updates" feed - "HrNotifications")
* - unread count -> unreadCount$ (DERIVED from notifications$, counts isRead !== true rows)
* - mark read -> openNotifications() marks the currently visible rows read RIGHT AWAY
* (optimistic: isRead flips locally so the badge clears instantly, the
* rows stay on screen so the panel doesn't go blank while still open)
* markVisibleAsReadThenRefresh() re-fetches on panel close, so a later
* open only shows notifications that are genuinely still unread
* - reset -> clear() (on logout)
*
* AppTopBarComponent and UserSSDashboardComponent are pure CONSUMERS: they
* subscribe to the observables above and never fetch / count / mark-read
* themselves. That is what keeps the two badges identical. No UI/template of
* the existing notification panel changes - only the data flow behind it.
*
* Backend notes:
* - /Workflow/getNotificationItemsESS returns a DataSet: { hrNotifications, otherNotifications }.
* - otherNotifications is actually TWO different sources UNION'd together - they need
* two different "mark read" calls:
* 1. EmployeeNotification rows: real `employeeNotificationID` (> 0) + `isRead` column.
* -> POST /Workflow/MarkNotificationsAsRead (batch of ids). Query already filters
* IsRead = 0 and caps at TOP 15, so a fresh fetch after mark-read can surface
* rows that were previously outside the window.
* 2. WFMOVEMENTTASK "SysNotification" rows: `employeeNotificationID` is always 0 here,
* there is NO IsRead column for these - they only have a WFMOVEMENTTASKID + a
* Status flag. -> POST /Workflow/updateSysNotification per row (WFMovementTask.ID
* = the row's WFMOVEMENTTASKID), which flips Status so the row drops out of the
* next fetch's `WHERE Status = 0` filter.
* Both kinds are treated as "unread" client-side via the same `isRead` flag on the row
* object (that flag does not exist on the SysNotification rows server-side - it is only
* ever set/read here, in this service).
*/
@Injectable()
export class NotificationTriggerService implements OnDestroy {
// -------- panel open trigger (unchanged public contract) --------
private notificationSource = new Subject<void>();
notificationSource$ = this.notificationSource.asObservable();
// -------- notification state --------
private notificationsSource = new BehaviorSubject<any[]>([]);
/** Rows shown in the notification bell / panel dropdown. */
readonly notifications$ = this.notificationsSource.asObservable();
private hrNotificationsSource = new BehaviorSubject<any[]>([]);
/** Rows shown in the dashboard "Company Updates & Notification" feed. */
readonly hrNotifications$ = this.hrNotificationsSource.asObservable();
/**
* Unread count DERIVED from the one list. Both the top-bar bell and the
* dashboard tile ultimately read this same list, so they can never diverge.
*/
readonly unreadCount$ = this.notificationsSource.pipe(
map(list => this.countUnread(list)),
distinctUntilChanged(),
shareReplay({ bufferSize: 1, refCount: false })
);
private jwtHelper = new JwtHelperService();
private loaded = false;
private inFlight$: Observable<void> | null = null;
private activeSeq = 0; // sequence of the request that owns inFlight$
private reqSeq = 0; // guards against a stale response overwriting newer state
private lastRefreshStartedAt = 0;
private routerSub: Subscription;
private logoutSub: Subscription;
constructor(private authService: AuthService,
private wfService: WorkflowService,
private router: Router) {
// Wipe notification state on logout so it never leaks into the next session.
this.logoutSub = this.authService.logout$.subscribe(() => this.clear());
// Re-fetch when the user lands on an ESS dashboard - mirrors the app's
// existing "refresh on dashboard entry" behaviour so notifications created
// while the user was elsewhere become visible. De-duped in refreshNotifications().
// NOTE: must match the actual route segments in ess-routing.module.ts
// ('self-dashboard', 'ess-dashboard', 'selfservice-dashboard') - this previously
// only listed 'user-ss-dashboard' / 'ess-dashboard', neither of which appears in
// the real URL '/ess/self-dashboard', so this trigger silently never fired for
// the most-used ESS landing page: only the one-time ensureLoaded() fetch (right
// after login) ever ran, and later visits to the page kept showing that same
// stale snapshot (Company Updates included) instead of fetching again.
this.routerSub = this.router.events.pipe(
filter((e): e is NavigationEnd => e instanceof NavigationEnd)
).subscribe(e => {
const url = e.urlAfterRedirects || e.url || '';
if (/self-dashboard|ess-dashboard|selfservice-dashboard/i.test(url)) {
this.refreshNotifications().subscribe();
}
});
}
ngOnDestroy(): void {
this.routerSub?.unsubscribe();
this.logoutSub?.unsubscribe();
}
// ------------------------------------------------------------------
// Panel open trigger
// ------------------------------------------------------------------
/** Opens (toggles) the shared notification panel that AppTopBarComponent renders. */
openNotifications(): void {
this.notificationSource.next();
// The user is looking at these rows right now - mark them read immediately
// so the badge/count clears without waiting for the panel to close.
this.markVisibleAsRead();
}
// ------------------------------------------------------------------
// Reads
// ------------------------------------------------------------------
/** Count shown on the badge = number of rows not yet marked read. */
countUnread(notifications: any[]): number {
return (notifications || []).filter(n => n && n.isRead !== true).length;
}
/** Back-compat alias for callers that pass an explicit list. */
getUnreadCount(notifications: any[]): number {
return this.countUnread(notifications);
}
get snapshot(): any[] {
return this.notificationsSource.value || [];
}
// ------------------------------------------------------------------
// Loading
// ------------------------------------------------------------------
/**
* Loads notifications once per session. Safe to call from every consumer's
* ngOnInit / login handler - the first call with a valid session wins, the
* rest are no-ops. Seeds instantly from localStorage for first paint, then
* refreshes from the API.
*/
ensureLoaded(): void {
if (this.loaded || this.inFlight$) { return; }
if (!this.getEmployeeId()) { return; } // no session yet - a later trigger will retry
this.seedFromCache();
this.refreshNotifications().subscribe();
}
/**
* Force a fresh fetch from the API and publish it to the store.
* Concurrent callers share ONE HTTP request. A response is applied only if it
* is still the newest request (stale responses are dropped).
*/
refreshNotifications(): Observable<void> {
if (this.inFlight$ && (Date.now() - this.lastRefreshStartedAt) < 1500) {
return this.inFlight$; // de-dupe rapid successive triggers
}
const employeeId = this.getEmployeeId();
if (!employeeId) { return of(void 0); }
const seq = ++this.reqSeq;
this.activeSeq = seq;
this.lastRefreshStartedAt = Date.now();
this.inFlight$ = this.wfService.getNotificationItemsESS(employeeId).pipe(
map((resp: any) => {
if (seq !== this.reqSeq) { return; } // superseded - ignore
const hr = this.normalizeList(resp && resp.hrNotifications);
let other = this.normalizeList(resp && resp.otherNotifications);
// if (other.length === 0) {
// other = [{
// type: 2, new: false,
// description: 'Welcome to GOHR self Dashboard!',
// sentTime: undefined, notificationUrl: '', isAttachment: 0
// }];
// }
this.persist(other);
this.hrNotificationsSource.next(hr);
this.notificationsSource.next(other);
this.loaded = true;
}),
catchError(err => {
console.error('[Notifications] refresh failed', err);
return of(void 0);
}),
finalize(() => { if (this.activeSeq === seq) { this.inFlight$ = null; } }),
shareReplay({ bufferSize: 1, refCount: false })
);
return this.inFlight$;
}
// ------------------------------------------------------------------
// Mark as read
// ------------------------------------------------------------------
/** Case-insensitive lookup - the raw DataTable's real column casing isn't guaranteed. */
private getTaskId(n: any): number {
if (!n) { return 0; }
const key = Object.keys(n).find(k => k.toLowerCase() === 'wfmovementtaskid');
const val = key ? n[key] : undefined;
return val != null ? Number(val) : 0;
}
private isSysNotificationRow(n: any): boolean {
return !!n && (n.employeeNotificationID == null || n.employeeNotificationID === 0) && this.getTaskId(n) > 0;
}
private getUnreadEmployeeNotificationIds(list: any[]): number[] {
return (list || [])
.filter(n => n && n.employeeNotificationID != null
&& n.employeeNotificationID > 0 && n.isRead !== true)
.map(n => n.employeeNotificationID);
}
private getUnreadSysNotificationTaskIds(list: any[]): number[] {
return (list || [])
.filter(n => n && n.isRead !== true && this.isSysNotificationRow(n))
.map(n => this.getTaskId(n));
}
private postMarkEmployeeNotificationsRead(ids: number[]): Observable<any> {
return ids.length === 0
? of(null)
: this.authService.markNotificationsAsRead(ids).pipe(
catchError(err => {
console.error('[Notifications] mark-as-read failed', err);
return of(null);
})
);
}
/** No batch endpoint for WFMOVEMENTTASK rows - one POST per task id. */
private postMarkSysNotificationsRead(taskIds: number[]): Observable<any> {
if (taskIds.length === 0) { return of(null); }
return forkJoin(taskIds.map(id =>
this.wfService.updateSysNotification({ id } as any).pipe(
catchError(err => {
console.error('[Notifications] sys-notification mark-as-read failed', err);
return of(null);
})
)
));
}
/**
* Fires the moment the notification panel opens (see openNotifications()).
* Optimistic: flips `isRead` on the currently visible rows straight away, so
* unreadCount$ - and every badge derived from it - drops instantly. The rows
* themselves stay in the list (not removed) so the open panel keeps showing
* what the user is looking at instead of going blank mid-read.
*/
private markVisibleAsRead(): void {
const current = this.notificationsSource.value || [];
const empIds = this.getUnreadEmployeeNotificationIds(current);
const taskIds = this.getUnreadSysNotificationTaskIds(current);
if (empIds.length === 0 && taskIds.length === 0) { return; }
const empIdSet = new Set(empIds);
const taskIdSet = new Set(taskIds);
const updated = current.map(n => {
const isTarget = (n.employeeNotificationID != null && empIdSet.has(n.employeeNotificationID))
|| (this.isSysNotificationRow(n) && taskIdSet.has(this.getTaskId(n)));
return isTarget ? { ...n, isRead: true } : n;
});
this.notificationsSource.next(updated);
this.persist(updated);
this.postMarkEmployeeNotificationsRead(empIds).subscribe();
this.postMarkSysNotificationsRead(taskIds).subscribe();
}
/**
* The full "notification panel closed" pipeline - used by BOTH entry points:
* 1. POST any still-unread ids (both kinds) -> wait for completion
* 2. re-fetch the latest notifications from the API (NOT the local array)
* 3. publish -> notifications$ / unreadCount$ emit -> both badges update
* By the time the panel closes, openNotifications() has usually already marked
* everything read, so this mainly re-syncs with the server (drops rows that are
* now actually read, pulls in anything new that arrived while the panel was open).
*/
markVisibleAsReadThenRefresh(): Observable<void> {
const current = this.notificationsSource.value || [];
const empIds = this.getUnreadEmployeeNotificationIds(current);
const taskIds = this.getUnreadSysNotificationTaskIds(current);
return forkJoin([
this.postMarkEmployeeNotificationsRead(empIds),
this.postMarkSysNotificationsRead(taskIds)
]).pipe(
switchMap(() => {
// We need genuinely fresh data now - bypass the de-dupe window.
this.inFlight$ = null;
this.lastRefreshStartedAt = 0;
return this.refreshNotifications();
})
);
}
// ------------------------------------------------------------------
// Reset (logout)
// ------------------------------------------------------------------
clear(): void {
this.reqSeq++; // invalidate any in-flight response
this.activeSeq = this.reqSeq;
this.inFlight$ = null;
this.loaded = false;
this.lastRefreshStartedAt = 0;
this.hrNotificationsSource.next([]);
this.notificationsSource.next([]);
try { localStorage.removeItem('notifications'); } catch { /* ignore */ }
}
// ------------------------------------------------------------------
// helpers
// ------------------------------------------------------------------
private seedFromCache(): void {
try {
const cached = JSON.parse(localStorage.getItem('notifications') || 'null');
if (Array.isArray(cached) && cached.length) {
this.notificationsSource.next(cached);
}
} catch { /* ignore bad cache */ }
}
private persist(list: any[]): void {
try { localStorage.setItem('notifications', JSON.stringify(list || [])); } catch { /* ignore */ }
}
private normalizeList(list: any): any[] {
const arr = Array.isArray(list) ? [...list] : [];
arr.forEach(n => this.normalizeUrl(n));
return arr;
}
/** Same URL normalisation the dashboard applied when it first loaded notifications. */
private normalizeUrl(task: any): void {
if (!task || !task.notificationUrl) { return; }
const url = ('' + task.notificationUrl).trim();
if (!url.toLowerCase().startsWith('http://') && !url.toLowerCase().startsWith('https://')) {
task.notificationUrl = 'http://' + url;
}
}
private getEmployeeId(): number | null {
try {
const user = this.jwtHelper.decodeToken(localStorage.getItem('token'));
return user && user.EmployeeID != null ? Number(user.EmployeeID) : null;
} catch { return null; }
}
}