@ieeesa-npm/dashboard 0.0.1 → 0.0.3

package/esm2022/lib/services/dashboard.service.mjs

@@ -2,10 +2,27 @@ import { Injectable } from '@angular/core';
 import { BehaviorSubject, catchError, map, of, } from 'rxjs';
 import { AttendanceState } from '../models/attendance-state.model';
 import { DashboardSectionState } from '../models/dashboard-section-state.model';
-import { DashboardGroupsMock, DashboardUpcomingEventsMock, } from '../assets/dashboard-mock';
+import { UpcomingItemKind, } from '../models/upcoming-event.model';
+import { mapEventMeetingDetails, mapEventMeetingList, } from '../utils/event-meeting-mapper.util';
 import { applyLeaveMeetingSuccess, applyLogAttendanceSuccess, beginAttendanceAction, endAttendanceAction, } from './attendance-reducers';
 import * as i0 from "@angular/core";
 import * as i1 from "@ieeesa-npm/utility";
+/** Fallback label for an empty group type / member level, matching the My Groups tab. */
+const UNASSIGNED_LABEL = 'Unassigned';
+/** Placeholder for an empty cell value. */
+const EMPTY_VALUE = '-';
+/** Statuses included in the upcoming section, matching the view-events-meetings-list screen. */
+const UPCOMING_STATUSES = ['In Progress', 'Upcoming'];
+/** Sort column used for the top-level events & meetings list. */
+const UPCOMING_SORT_COLUMN = 'startDateTime';
+/** Sort column used for an event's expanded child-meeting list (meetingsDetails). */
+const EVENT_MEETINGS_SORT_COLUMN = 'meetingStDate';
+/** Default page size for the top-level upcoming section list. */
+const UPCOMING_PAGE_SIZE = 10;
+/** Default page size for an event's expanded child-meeting list. */
+const EVENT_MEETINGS_PAGE_SIZE = 5;
+/** Large page size used by the eager count prefetch to capture the full set. */
+const EVENT_COUNT_PAGE_SIZE = 200;
 /**
  * DashboardService is the single source of truth for the dashboard landing
  * page's data and attendance state. It mirrors the `events-and-meetings`
@@ -15,11 +32,12 @@ import * as i1 from "@ieeesa-npm/utility";
  * through the shared `HttpService` from `@ieeesa-npm/utility` (never
  * `HttpClient` directly).
  *
- * The upcoming-events and groups loads currently return annotated mock data
- * because their endpoints are not yet available; the attendance actions compose
- * the pure reducers from `attendance-reducers.ts` so the displayed
- * `AttendanceState` only advances on a successful resolution and the prior
- * state is retained on failure.
+ * The upcoming-events load calls the real `POST /meetings/eventsAndMeetings`
+ * endpoint (child meetings are lazily loaded per-event via
+ * `POST /meetings/meetingsDetails`); the groups load calls `GET
+ * /groups/my-groups`. The attendance actions compose the pure reducers from
+ * `attendance-reducers.ts` so the displayed `AttendanceState` only advances on a
+ * successful resolution and the prior state is retained on failure.
  * @export
  * @class DashboardService
  */
@@ -62,35 +80,172 @@ export class DashboardService {
         this.userPermissions = userPermissions;
     }
     /**
-     * Loads the user's upcoming events, driving the upcoming section through
-     * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on
-     * failure. Follows the `pipe(map, catchError(throw))` pattern and seeds the
-     * per-meeting attendance-state map from the loaded meetings.
-     *
-     * TODO: Replace mock with real API call when BE is ready
-     * @return {Observable<DashboardListResponse<UpcomingEvent[]>>} The upcoming-events response envelope.
+     * Loads the user's upcoming events & meetings from the real backend via
+     * `POST {apiBaseUrl}/meetings/eventsAndMeetings`, the same endpoint the
+     * `view-events-meetings-list` screen uses. The response is mapped into the
+     * dashboard view models (with STANDALONE_MEETING rows ordered last), the
+     * per-meeting attendance-state map is seeded, and the section advances through
+     * LOADING → LOADED/EMPTY on success, leaving the caller to set ERROR on
+     * failure. Follows the shared `pipe(map, catchError(throw))` pattern.
+     * @return {Observable<EventMeetingListResponse>} The upcoming events & meetings response envelope.
      * @memberof DashboardService
      */
     loadUpcomingEvents() {
         this.upcomingState.next(DashboardSectionState.LOADING);
-        // TODO: Replace mock with real API call when BE is ready
-        const response$ = of({
-            status: true,
-            body: DashboardUpcomingEventsMock,
-        });
-        return response$.pipe(map((response) => {
-            const events = response?.body ?? [];
+        const payload = {
+            payload: {
+                eventId: null,
+                sortColumn: UPCOMING_SORT_COLUMN,
+                ascendingOrder: true,
+                page: 1,
+                size: UPCOMING_PAGE_SIZE,
+                filter: {
+                    status: UPCOMING_STATUSES,
+                    isAllMeetingSelected: false,
+                },
+            },
+        };
+        return this.httpService
+            .postData(`${this.apiBaseUrl}/meetings/eventsAndMeetings`, payload)
+            .pipe(map((response) => {
+            const events = mapEventMeetingList(response?.body?.eventMeetingList ?? []);
             this.upcomingEvents.next(events);
             this.seedAttendanceStates(events);
             this.upcomingState.next(events.length > 0
                 ? DashboardSectionState.LOADED
                 : DashboardSectionState.EMPTY);
+            // Eagerly fetch each EVENT's meeting count so the "{n} meetings" and
+            // "{n} open for attendance" summaries are correct before expanding.
+            this.loadEventCounts(events);
             return response;
         }), catchError((error) => {
             this.upcomingState.next(DashboardSectionState.ERROR);
             throw error;
         }));
     }
+    /**
+     * Lazily loads (and paginates) the child meetings of an EVENT row via
+     * `POST {apiBaseUrl}/meetings/meetingsDetails` — the per-event expand endpoint
+     * used by the reference screen. On success the loaded meetings are mapped and
+     * merged onto the matching event in the `upcomingEvents` list (with its
+     * `meetingCount` / `openForAttendanceCount` refreshed), and the per-meeting
+     * attendance-state map is extended. Each event paginates independently.
+     * @param {string} eventId - The event whose meetings to load.
+     * @param {number} [page=1] - The one-based page to request.
+     * @param {number} [size=EVENT_MEETINGS_PAGE_SIZE] - The page size.
+     * @return {Observable<EventMeetingDetailResponse>} The child-meetings response envelope.
+     * @memberof DashboardService
+     */
+    loadEventMeetings(eventId, page = 1, size = EVENT_MEETINGS_PAGE_SIZE) {
+        return this.fetchEventMeetingsPage(eventId, page, size).pipe(map((response) => {
+            const meetings = mapEventMeetingDetails(response?.body?.meetings ?? []);
+            const total = response?.body?.totalRecords ?? meetings.length;
+            // Prefer the already-known full open count on the event; fall back to
+            // the current page's open count when it hasn't been prefetched.
+            const existing = this.upcomingEvents.value.find((event) => event.eventId === eventId);
+            const pageOpenCount = meetings.filter((meeting) => meeting.isOpenForAttendance).length;
+            const openForAttendanceCount = existing?.openForAttendanceCount || pageOpenCount;
+            this.mergeEventMeetings(eventId, meetings, total, openForAttendanceCount);
+            this.seedAttendanceStatesFromMeetings(meetings);
+            return response;
+        }), catchError((error) => {
+            throw error;
+        }));
+    }
+    /**
+     * Merges a freshly loaded page of child meetings onto the matching event in
+     * the `upcomingEvents` list, refreshing the event's `meetings`,
+     * `meetingCount` (from the backend `totalRecords`), and
+     * `openForAttendanceCount`. Leaves all other events untouched.
+     * @param {string} eventId - The event to merge meetings onto.
+     * @param {MeetingRow[]} meetings - The mapped child meetings for the page.
+     * @param {number} totalRecords - The event's total meeting count from the backend.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    mergeEventMeetings(eventId, meetings, totalRecords, openForAttendanceCount) {
+        const next = this.upcomingEvents.value.map((event) => {
+            if (event.eventId !== eventId) {
+                return event;
+            }
+            return {
+                ...event,
+                meetings,
+                meetingCount: totalRecords,
+                openForAttendanceCount,
+            };
+        });
+        this.upcomingEvents.next(next);
+    }
+    /**
+     * Eagerly fetches each EVENT's total meeting count and open-for-attendance
+     * count by requesting a large first page of its child meetings, then merging
+     * only the counts (not the rows) so the collapsed card summaries are accurate
+     * before the user expands. Standalone meetings are skipped. Failures per event
+     * are swallowed so one failing count never breaks the list.
+     * @param {UpcomingEvent[]} events - The loaded events to fetch counts for.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    loadEventCounts(events) {
+        events
+            .filter((event) => event.kind === UpcomingItemKind.EVENT && event.eventId)
+            .forEach((event) => {
+            this.fetchEventMeetingsPage(event.eventId, 1, EVENT_COUNT_PAGE_SIZE)
+                .pipe(catchError(() => of(null)))
+                .subscribe((response) => {
+                if (!response) {
+                    return;
+                }
+                const meetings = mapEventMeetingDetails(response?.body?.meetings ?? []);
+                const total = response?.body?.totalRecords ?? meetings.length;
+                const openCount = meetings.filter((meeting) => meeting.isOpenForAttendance).length;
+                this.mergeEventCounts(event.eventId, total, openCount);
+                this.seedAttendanceStatesFromMeetings(meetings);
+            });
+        });
+    }
+    /**
+     * Merges only the meeting counts onto the matching event, leaving its
+     * `meetings` rows untouched (used by the eager count prefetch).
+     * @param {string} eventId - The event to update.
+     * @param {number} totalRecords - The event's total meeting count.
+     * @param {number} openForAttendanceCount - The open-for-attendance count.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    mergeEventCounts(eventId, totalRecords, openForAttendanceCount) {
+        const next = this.upcomingEvents.value.map((event) => event.eventId === eventId
+            ? { ...event, meetingCount: totalRecords, openForAttendanceCount }
+            : event);
+        this.upcomingEvents.next(next);
+    }
+    /**
+     * Builds and posts the `meetingsDetails` request for a single event page,
+     * returning the raw response envelope. Shared by {@link loadEventMeetings} and
+     * the eager count prefetch.
+     * @param {string} eventId - The event whose meetings to fetch.
+     * @param {number} page - The one-based page to request.
+     * @param {number} size - The page size.
+     * @return {Observable<EventMeetingDetailResponse>} The child-meetings response.
+     * @memberof DashboardService
+     */
+    fetchEventMeetingsPage(eventId, page, size) {
+        const payload = {
+            payload: {
+                eventId,
+                sortColumn: EVENT_MEETINGS_SORT_COLUMN,
+                ascendingOrder: true,
+                page,
+                size,
+                filter: {
+                    status: UPCOMING_STATUSES,
+                    isAllMeetingSelected: false,
+                },
+            },
+        };
+        return this.httpService.postData(`${this.apiBaseUrl}/meetings/meetingsDetails`, payload);
+    }
     /**
      * Loads the user's groups, driving the groups section through
      * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on
@@ -102,13 +257,10 @@ export class DashboardService {
      */
     loadGroups() {
         this.groupsState.next(DashboardSectionState.LOADING);
-        // TODO: Replace mock with real API call when BE is ready
-        const response$ = of({
-            status: true,
-            body: DashboardGroupsMock,
-        });
-        return response$.pipe(map((response) => {
-            const groups = response?.body ?? [];
+        return this.httpService
+            .getData(`${this.apiBaseUrl}/groups/my-groups`)
+            .pipe(map((response) => {
+            const groups = (response?.body?.groups ?? []).map((group) => this.mapGroup(group));
             this.groups.next(groups);
             this.groupsState.next(groups.length > 0
                 ? DashboardSectionState.LOADED
@@ -119,6 +271,35 @@ export class DashboardService {
             throw error;
         }));
     }
+    /**
+     * Maps a backend {@link MyGroupView} to the table-facing {@link GroupRow}.
+     * Mirrors the My Groups profile tab: the type falls back to "Unassigned" when
+     * `groupTypeName` is null, affiliations are comma-joined, empty officer role /
+     * affiliation render as a placeholder, and a blank member level becomes
+     * "Unassigned" (rendered as the warning pill by the Your Groups component).
+     * @param {MyGroupView} group - The backend group view.
+     * @return {GroupRow}
+     * @memberof DashboardService
+     */
+    mapGroup(group) {
+        // The backend returns officer roles as an `officer` array of
+        // { officerId, officerName }. Join the names for the Officer Role column
+        // (e.g. "Chair" or "Chair, Vice Chair"); show the placeholder when empty.
+        const officerRole = (group.officer ?? [])
+            .map((officer) => officer?.officerName?.trim())
+            .filter((name) => !!name)
+            .join(', ') || EMPTY_VALUE;
+        return {
+            groupId: group.groupId,
+            group: group.groupName,
+            type: group.groupTypeName || group.groupType || UNASSIGNED_LABEL,
+            officerRole,
+            affiliation: group.affiliations?.join(', ') || EMPTY_VALUE,
+            memberLevel: group.memberLevel?.trim() || UNASSIGNED_LABEL,
+            // Carry the ancestor hierarchy through for the expandable hierarchy rows.
+            hierarchy: group.hierarchy ?? [],
+        };
+    }
     /**
      * Logs attendance for a meeting. Marks the meeting in-flight (retaining the
      * prior displayed state), posts through `HttpService`, applies the
@@ -183,16 +364,29 @@ export class DashboardService {
      * @memberof DashboardService
      */
     seedAttendanceStates(events) {
+        const meetings = events.flatMap((event) => event.meetings ?? []);
+        this.seedAttendanceStatesFromMeetings(meetings);
+    }
+    /**
+     * Seeds the attendance-state map from a list of meeting rows, using each
+     * meeting's `attendanceState` (defaulting to `NOT_ATTENDING`) without
+     * overwriting ids absent from the new list. Shared by the list load and the
+     * per-event expand so freshly loaded child meetings pick up their state.
+     * @param {MeetingRow[]} meetings - The meeting rows to seed from.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    seedAttendanceStatesFromMeetings(meetings) {
         const next = {
             ...this.attendanceStates.value,
         };
-        events.forEach((event) => {
-            event.meetings?.forEach((meeting) => {
-                if (meeting.meetingId) {
-                    next[meeting.meetingId] =
-                        meeting.attendanceState ?? AttendanceState.NOT_ATTENDING;
-                }
-            });
+        meetings.forEach((meeting) => {
+            if (meeting.meetingId) {
+                next[meeting.meetingId] =
+                    meeting.attendanceState ??
+                        next[meeting.meetingId] ??
+                        AttendanceState.NOT_ATTENDING;
+            }
         });
         this.attendanceStates.next(next);
     }
@@ -205,4 +399,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.HttpService }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.service.js","sourceRoot":"","sources":["../../../../../projects/dashboard/src/lib/services/dashboard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport {\r\n  BehaviorSubject,\r\n  Observable,\r\n  catchError,\r\n  map,\r\n  of,\r\n} from 'rxjs';\r\nimport { HttpService } from '@ieeesa-npm/utility';\r\nimport { UserPermission } from '@ieeesa-npm/models';\r\nimport { AttendanceState } from '../models/attendance-state.model';\r\nimport { DashboardListResponse } from '../models/dashboard-list-response.model';\r\nimport { DashboardSectionState } from '../models/dashboard-section-state.model';\r\nimport { GroupRow } from '../models/group-row.model';\r\nimport { UpcomingEvent } from '../models/upcoming-event.model';\r\nimport {\r\n  DashboardGroupsMock,\r\n  DashboardUpcomingEventsMock,\r\n} from '../assets/dashboard-mock';\r\nimport {\r\n  applyLeaveMeetingSuccess,\r\n  applyLogAttendanceSuccess,\r\n  beginAttendanceAction,\r\n  endAttendanceAction,\r\n} from './attendance-reducers';\r\n\r\n/**\r\n * DashboardService is the single source of truth for the dashboard landing\r\n * page's data and attendance state. It mirrors the `events-and-meetings`\r\n * service conventions: it is a `providedIn: 'root'` singleton, holds the host\r\n * `apiBaseUrl` / `userPermissions` set via {@link setAppConfig}, owns its state\r\n * via `BehaviorSubject`s exposed as observables, and reaches the backend only\r\n * through the shared `HttpService` from `@ieeesa-npm/utility` (never\r\n * `HttpClient` directly).\r\n *\r\n * The upcoming-events and groups loads currently return annotated mock data\r\n * because their endpoints are not yet available; the attendance actions compose\r\n * the pure reducers from `attendance-reducers.ts` so the displayed\r\n * `AttendanceState` only advances on a successful resolution and the prior\r\n * state is retained on failure.\r\n * @export\r\n * @class DashboardService\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class DashboardService {\r\n  apiBaseUrl!: string;\r\n  userPermissions!: UserPermission[];\r\n\r\n  private readonly upcomingEvents = new BehaviorSubject<UpcomingEvent[]>([]);\r\n  private readonly groups = new BehaviorSubject<GroupRow[]>([]);\r\n  private readonly upcomingState = new BehaviorSubject<DashboardSectionState>(\r\n    DashboardSectionState.LOADING\r\n  );\r\n  private readonly groupsState = new BehaviorSubject<DashboardSectionState>(\r\n    DashboardSectionState.LOADING\r\n  );\r\n  private readonly attendanceStates = new BehaviorSubject<\r\n    Record<string, AttendanceState>\r\n  >({});\r\n  private readonly inFlightMeetingIds = new BehaviorSubject<\r\n    ReadonlySet<string>\r\n  >(new Set<string>());\r\n\r\n  /** Emits the list of the user's upcoming events. */\r\n  upcomingEvents$: Observable<UpcomingEvent[]> =\r\n    this.upcomingEvents.asObservable();\r\n  /** Emits the list of the user's groups. */\r\n  groups$: Observable<GroupRow[]> = this.groups.asObservable();\r\n  /** Emits the load/empty/error state of the upcoming-events section. */\r\n  upcomingState$: Observable<DashboardSectionState> =\r\n    this.upcomingState.asObservable();\r\n  /** Emits the load/empty/error state of the groups section. */\r\n  groupsState$: Observable<DashboardSectionState> =\r\n    this.groupsState.asObservable();\r\n  /** Emits the per-meeting attendance-state map. */\r\n  attendanceStates$: Observable<Record<string, AttendanceState>> =\r\n    this.attendanceStates.asObservable();\r\n  /** Emits the set of meeting ids with an attendance action in flight. */\r\n  inFlightMeetingIds$: Observable<ReadonlySet<string>> =\r\n    this.inFlightMeetingIds.asObservable();\r\n\r\n  constructor(\r\n    // eslint-disable-next-line no-unused-vars\r\n    private httpService: HttpService // eslint-disable-next-line no-empty-function\r\n  ) {}\r\n\r\n  /**\r\n   * Stores the host-supplied API base URL and user permissions used to build\r\n   * request URLs and gate permission-controlled actions. Mirrors the\r\n   * `events-and-meetings` service `setAppConfig`.\r\n   * @param {string} apiBaseURL - The host application's API base URL.\r\n   * @param {UserPermission[]} userPermissions - The signed-in user's permissions.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  setAppConfig(apiBaseURL: string, userPermissions: UserPermission[]): void {\r\n    this.apiBaseUrl = apiBaseURL;\r\n    this.userPermissions = userPermissions;\r\n  }\r\n\r\n  /**\r\n   * Loads the user's upcoming events, driving the upcoming section through\r\n   * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on\r\n   * failure. Follows the `pipe(map, catchError(throw))` pattern and seeds the\r\n   * per-meeting attendance-state map from the loaded meetings.\r\n   *\r\n   * TODO: Replace mock with real API call when BE is ready\r\n   * @return {Observable<DashboardListResponse<UpcomingEvent[]>>} The upcoming-events response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  loadUpcomingEvents(): Observable<DashboardListResponse<UpcomingEvent[]>> {\r\n    this.upcomingState.next(DashboardSectionState.LOADING);\r\n    // TODO: Replace mock with real API call when BE is ready\r\n    const response$: Observable<DashboardListResponse<UpcomingEvent[]>> = of({\r\n      status: true,\r\n      body: DashboardUpcomingEventsMock,\r\n    });\r\n    return response$.pipe(\r\n      map((response) => {\r\n        const events = response?.body ?? [];\r\n        this.upcomingEvents.next(events);\r\n        this.seedAttendanceStates(events);\r\n        this.upcomingState.next(\r\n          events.length > 0\r\n            ? DashboardSectionState.LOADED\r\n            : DashboardSectionState.EMPTY\r\n        );\r\n        return response;\r\n      }),\r\n      catchError((error) => {\r\n        this.upcomingState.next(DashboardSectionState.ERROR);\r\n        throw error;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Loads the user's groups, driving the groups section through\r\n   * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on\r\n   * failure. Follows the `pipe(map, catchError(throw))` pattern.\r\n   *\r\n   * TODO: Replace mock with real API call when BE is ready\r\n   * @return {Observable<DashboardListResponse<GroupRow[]>>} The groups response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  loadGroups(): Observable<DashboardListResponse<GroupRow[]>> {\r\n    this.groupsState.next(DashboardSectionState.LOADING);\r\n    // TODO: Replace mock with real API call when BE is ready\r\n    const response$: Observable<DashboardListResponse<GroupRow[]>> = of({\r\n      status: true,\r\n      body: DashboardGroupsMock,\r\n    });\r\n    return response$.pipe(\r\n      map((response) => {\r\n        const groups = response?.body ?? [];\r\n        this.groups.next(groups);\r\n        this.groupsState.next(\r\n          groups.length > 0\r\n            ? DashboardSectionState.LOADED\r\n            : DashboardSectionState.EMPTY\r\n        );\r\n        return response;\r\n      }),\r\n      catchError((error) => {\r\n        this.groupsState.next(DashboardSectionState.ERROR);\r\n        throw error;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Logs attendance for a meeting. Marks the meeting in-flight (retaining the\r\n   * prior displayed state), posts through `HttpService`, applies the\r\n   * log-attendance-success reducer on success, clears the in-flight flag on\r\n   * completion, and rethrows while retaining prior state on failure.\r\n   * @param {string} meetingId - The meeting to log attendance for.\r\n   * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  logAttendance(\r\n    meetingId: string\r\n  ): Observable<DashboardListResponse<unknown>> {\r\n    this.inFlightMeetingIds.next(\r\n      beginAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n    );\r\n    return this.httpService\r\n      .postData(`${this.apiBaseUrl}/meetings/attendance/log`, { meetingId })\r\n      .pipe(\r\n        map((response) => {\r\n          this.attendanceStates.next(\r\n            applyLogAttendanceSuccess(this.attendanceStates.value, meetingId)\r\n          );\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          return response;\r\n        }),\r\n        catchError((error) => {\r\n          // Retain prior attendance state; only clear the in-flight flag.\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          throw error;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Leaves a meeting. Marks the meeting in-flight (retaining the prior\r\n   * displayed state), posts through `HttpService`, applies the\r\n   * leave-meeting-success reducer on success, clears the in-flight flag on\r\n   * completion, and rethrows while retaining prior state on failure.\r\n   * @param {string} meetingId - The meeting to leave.\r\n   * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  leaveMeeting(\r\n    meetingId: string\r\n  ): Observable<DashboardListResponse<unknown>> {\r\n    this.inFlightMeetingIds.next(\r\n      beginAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n    );\r\n    return this.httpService\r\n      .postData(`${this.apiBaseUrl}/meetings/attendance/leave`, { meetingId })\r\n      .pipe(\r\n        map((response) => {\r\n          this.attendanceStates.next(\r\n            applyLeaveMeetingSuccess(this.attendanceStates.value, meetingId)\r\n          );\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          return response;\r\n        }),\r\n        catchError((error) => {\r\n          // Retain prior attendance state; only clear the in-flight flag.\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          throw error;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Returns a synchronous snapshot of the per-meeting attendance-state map.\r\n   * @return {Record<string, AttendanceState>} The current attendance-state map.\r\n   * @memberof DashboardService\r\n   */\r\n  getAttendanceStatesSnapshot(): Record<string, AttendanceState> {\r\n    return this.attendanceStates.value;\r\n  }\r\n\r\n  /**\r\n   * Seeds the attendance-state map from a freshly loaded list of events, using\r\n   * each meeting's `attendanceState` (defaulting to `NOT_ATTENDING`). Keeps the\r\n   * displayed state in sync with the data load without overwriting ids that are\r\n   * not present in the new list.\r\n   * @param {UpcomingEvent[]} events - The loaded upcoming events.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  private seedAttendanceStates(events: UpcomingEvent[]): void {\r\n    const next: Record<string, AttendanceState> = {\r\n      ...this.attendanceStates.value,\r\n    };\r\n    events.forEach((event) => {\r\n      event.meetings?.forEach((meeting) => {\r\n        if (meeting.meetingId) {\r\n          next[meeting.meetingId] =\r\n            meeting.attendanceState ?? AttendanceState.NOT_ATTENDING;\r\n        }\r\n      });\r\n    });\r\n    this.attendanceStates.next(next);\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.service.js","sourceRoot":"","sources":["../../../../../projects/dashboard/src/lib/services/dashboard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport {\r\n  BehaviorSubject,\r\n  Observable,\r\n  catchError,\r\n  map,\r\n  of,\r\n} from 'rxjs';\r\nimport { HttpService } from '@ieeesa-npm/utility';\r\nimport { UserPermission } from '@ieeesa-npm/models';\r\nimport { AttendanceState } from '../models/attendance-state.model';\r\nimport { DashboardListResponse } from '../models/dashboard-list-response.model';\r\nimport { DashboardSectionState } from '../models/dashboard-section-state.model';\r\nimport { GroupRow } from '../models/group-row.model';\r\nimport {\r\n  MyGroupsView,\r\n  MyGroupView,\r\n} from '../models/my-groups-view.model';\r\nimport {\r\n  UpcomingEvent,\r\n  UpcomingItemKind,\r\n} from '../models/upcoming-event.model';\r\nimport {\r\n  EventMeetingDetailPayload,\r\n  EventMeetingListPayload,\r\n} from '../models/event-meeting-list-payload.model';\r\nimport {\r\n  EventMeetingDetailResponse,\r\n  EventMeetingListResponse,\r\n} from '../models/event-meeting-list-item.model';\r\nimport {\r\n  mapEventMeetingDetails,\r\n  mapEventMeetingList,\r\n} from '../utils/event-meeting-mapper.util';\r\nimport { MeetingRow } from '../models/meeting-row.model';\r\n\r\n/** Fallback label for an empty group type / member level, matching the My Groups tab. */\r\nconst UNASSIGNED_LABEL = 'Unassigned';\r\n/** Placeholder for an empty cell value. */\r\nconst EMPTY_VALUE = '-';\r\n/** Statuses included in the upcoming section, matching the view-events-meetings-list screen. */\r\nconst UPCOMING_STATUSES = ['In Progress', 'Upcoming'];\r\n/** Sort column used for the top-level events & meetings list. */\r\nconst UPCOMING_SORT_COLUMN = 'startDateTime';\r\n/** Sort column used for an event's expanded child-meeting list (meetingsDetails). */\r\nconst EVENT_MEETINGS_SORT_COLUMN = 'meetingStDate';\r\n/** Default page size for the top-level upcoming section list. */\r\nconst UPCOMING_PAGE_SIZE = 10;\r\n/** Default page size for an event's expanded child-meeting list. */\r\nconst EVENT_MEETINGS_PAGE_SIZE = 5;\r\n/** Large page size used by the eager count prefetch to capture the full set. */\r\nconst EVENT_COUNT_PAGE_SIZE = 200;\r\nimport {\r\n  applyLeaveMeetingSuccess,\r\n  applyLogAttendanceSuccess,\r\n  beginAttendanceAction,\r\n  endAttendanceAction,\r\n} from './attendance-reducers';\r\n\r\n/**\r\n * DashboardService is the single source of truth for the dashboard landing\r\n * page's data and attendance state. It mirrors the `events-and-meetings`\r\n * service conventions: it is a `providedIn: 'root'` singleton, holds the host\r\n * `apiBaseUrl` / `userPermissions` set via {@link setAppConfig}, owns its state\r\n * via `BehaviorSubject`s exposed as observables, and reaches the backend only\r\n * through the shared `HttpService` from `@ieeesa-npm/utility` (never\r\n * `HttpClient` directly).\r\n *\r\n * The upcoming-events load calls the real `POST /meetings/eventsAndMeetings`\r\n * endpoint (child meetings are lazily loaded per-event via\r\n * `POST /meetings/meetingsDetails`); the groups load calls `GET\r\n * /groups/my-groups`. The attendance actions compose the pure reducers from\r\n * `attendance-reducers.ts` so the displayed `AttendanceState` only advances on a\r\n * successful resolution and the prior state is retained on failure.\r\n * @export\r\n * @class DashboardService\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class DashboardService {\r\n  apiBaseUrl!: string;\r\n  userPermissions!: UserPermission[];\r\n\r\n  private readonly upcomingEvents = new BehaviorSubject<UpcomingEvent[]>([]);\r\n  private readonly groups = new BehaviorSubject<GroupRow[]>([]);\r\n  private readonly upcomingState = new BehaviorSubject<DashboardSectionState>(\r\n    DashboardSectionState.LOADING\r\n  );\r\n  private readonly groupsState = new BehaviorSubject<DashboardSectionState>(\r\n    DashboardSectionState.LOADING\r\n  );\r\n  private readonly attendanceStates = new BehaviorSubject<\r\n    Record<string, AttendanceState>\r\n  >({});\r\n  private readonly inFlightMeetingIds = new BehaviorSubject<\r\n    ReadonlySet<string>\r\n  >(new Set<string>());\r\n\r\n  /** Emits the list of the user's upcoming events. */\r\n  upcomingEvents$: Observable<UpcomingEvent[]> =\r\n    this.upcomingEvents.asObservable();\r\n  /** Emits the list of the user's groups. */\r\n  groups$: Observable<GroupRow[]> = this.groups.asObservable();\r\n  /** Emits the load/empty/error state of the upcoming-events section. */\r\n  upcomingState$: Observable<DashboardSectionState> =\r\n    this.upcomingState.asObservable();\r\n  /** Emits the load/empty/error state of the groups section. */\r\n  groupsState$: Observable<DashboardSectionState> =\r\n    this.groupsState.asObservable();\r\n  /** Emits the per-meeting attendance-state map. */\r\n  attendanceStates$: Observable<Record<string, AttendanceState>> =\r\n    this.attendanceStates.asObservable();\r\n  /** Emits the set of meeting ids with an attendance action in flight. */\r\n  inFlightMeetingIds$: Observable<ReadonlySet<string>> =\r\n    this.inFlightMeetingIds.asObservable();\r\n\r\n  constructor(\r\n    // eslint-disable-next-line no-unused-vars\r\n    private httpService: HttpService // eslint-disable-next-line no-empty-function\r\n  ) {}\r\n\r\n  /**\r\n   * Stores the host-supplied API base URL and user permissions used to build\r\n   * request URLs and gate permission-controlled actions. Mirrors the\r\n   * `events-and-meetings` service `setAppConfig`.\r\n   * @param {string} apiBaseURL - The host application's API base URL.\r\n   * @param {UserPermission[]} userPermissions - The signed-in user's permissions.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  setAppConfig(apiBaseURL: string, userPermissions: UserPermission[]): void {\r\n    this.apiBaseUrl = apiBaseURL;\r\n    this.userPermissions = userPermissions;\r\n  }\r\n\r\n  /**\r\n   * Loads the user's upcoming events & meetings from the real backend via\r\n   * `POST {apiBaseUrl}/meetings/eventsAndMeetings`, the same endpoint the\r\n   * `view-events-meetings-list` screen uses. The response is mapped into the\r\n   * dashboard view models (with STANDALONE_MEETING rows ordered last), the\r\n   * per-meeting attendance-state map is seeded, and the section advances through\r\n   * LOADING → LOADED/EMPTY on success, leaving the caller to set ERROR on\r\n   * failure. Follows the shared `pipe(map, catchError(throw))` pattern.\r\n   * @return {Observable<EventMeetingListResponse>} The upcoming events & meetings response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  loadUpcomingEvents(): Observable<EventMeetingListResponse> {\r\n    this.upcomingState.next(DashboardSectionState.LOADING);\r\n    const payload: EventMeetingListPayload = {\r\n      payload: {\r\n        eventId: null,\r\n        sortColumn: UPCOMING_SORT_COLUMN,\r\n        ascendingOrder: true,\r\n        page: 1,\r\n        size: UPCOMING_PAGE_SIZE,\r\n        filter: {\r\n          status: UPCOMING_STATUSES,\r\n          isAllMeetingSelected: false,\r\n        },\r\n      },\r\n    };\r\n    return this.httpService\r\n      .postData(`${this.apiBaseUrl}/meetings/eventsAndMeetings`, payload)\r\n      .pipe(\r\n        map((response: EventMeetingListResponse) => {\r\n          const events = mapEventMeetingList(\r\n            response?.body?.eventMeetingList ?? []\r\n          );\r\n          this.upcomingEvents.next(events);\r\n          this.seedAttendanceStates(events);\r\n          this.upcomingState.next(\r\n            events.length > 0\r\n              ? DashboardSectionState.LOADED\r\n              : DashboardSectionState.EMPTY\r\n          );\r\n          // Eagerly fetch each EVENT's meeting count so the \"{n} meetings\" and\r\n          // \"{n} open for attendance\" summaries are correct before expanding.\r\n          this.loadEventCounts(events);\r\n          return response;\r\n        }),\r\n        catchError((error) => {\r\n          this.upcomingState.next(DashboardSectionState.ERROR);\r\n          throw error;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Lazily loads (and paginates) the child meetings of an EVENT row via\r\n   * `POST {apiBaseUrl}/meetings/meetingsDetails` — the per-event expand endpoint\r\n   * used by the reference screen. On success the loaded meetings are mapped and\r\n   * merged onto the matching event in the `upcomingEvents` list (with its\r\n   * `meetingCount` / `openForAttendanceCount` refreshed), and the per-meeting\r\n   * attendance-state map is extended. Each event paginates independently.\r\n   * @param {string} eventId - The event whose meetings to load.\r\n   * @param {number} [page=1] - The one-based page to request.\r\n   * @param {number} [size=EVENT_MEETINGS_PAGE_SIZE] - The page size.\r\n   * @return {Observable<EventMeetingDetailResponse>} The child-meetings response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  loadEventMeetings(\r\n    eventId: string,\r\n    page = 1,\r\n    size = EVENT_MEETINGS_PAGE_SIZE\r\n  ): Observable<EventMeetingDetailResponse> {\r\n    return this.fetchEventMeetingsPage(eventId, page, size).pipe(\r\n      map((response: EventMeetingDetailResponse) => {\r\n        const meetings = mapEventMeetingDetails(\r\n          response?.body?.meetings ?? []\r\n        );\r\n        const total = response?.body?.totalRecords ?? meetings.length;\r\n        // Prefer the already-known full open count on the event; fall back to\r\n        // the current page's open count when it hasn't been prefetched.\r\n        const existing = this.upcomingEvents.value.find(\r\n          (event) => event.eventId === eventId\r\n        );\r\n        const pageOpenCount = meetings.filter(\r\n          (meeting) => meeting.isOpenForAttendance\r\n        ).length;\r\n        const openForAttendanceCount =\r\n          existing?.openForAttendanceCount || pageOpenCount;\r\n        this.mergeEventMeetings(eventId, meetings, total, openForAttendanceCount);\r\n        this.seedAttendanceStatesFromMeetings(meetings);\r\n        return response;\r\n      }),\r\n      catchError((error) => {\r\n        throw error;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Merges a freshly loaded page of child meetings onto the matching event in\r\n   * the `upcomingEvents` list, refreshing the event's `meetings`,\r\n   * `meetingCount` (from the backend `totalRecords`), and\r\n   * `openForAttendanceCount`. Leaves all other events untouched.\r\n   * @param {string} eventId - The event to merge meetings onto.\r\n   * @param {MeetingRow[]} meetings - The mapped child meetings for the page.\r\n   * @param {number} totalRecords - The event's total meeting count from the backend.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  private mergeEventMeetings(\r\n    eventId: string,\r\n    meetings: MeetingRow[],\r\n    totalRecords: number,\r\n    openForAttendanceCount: number\r\n  ): void {\r\n    const next = this.upcomingEvents.value.map((event) => {\r\n      if (event.eventId !== eventId) {\r\n        return event;\r\n      }\r\n      return {\r\n        ...event,\r\n        meetings,\r\n        meetingCount: totalRecords,\r\n        openForAttendanceCount,\r\n      };\r\n    });\r\n    this.upcomingEvents.next(next);\r\n  }\r\n\r\n  /**\r\n   * Eagerly fetches each EVENT's total meeting count and open-for-attendance\r\n   * count by requesting a large first page of its child meetings, then merging\r\n   * only the counts (not the rows) so the collapsed card summaries are accurate\r\n   * before the user expands. Standalone meetings are skipped. Failures per event\r\n   * are swallowed so one failing count never breaks the list.\r\n   * @param {UpcomingEvent[]} events - The loaded events to fetch counts for.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  private loadEventCounts(events: UpcomingEvent[]): void {\r\n    events\r\n      .filter((event) => event.kind === UpcomingItemKind.EVENT && event.eventId)\r\n      .forEach((event) => {\r\n        this.fetchEventMeetingsPage(event.eventId, 1, EVENT_COUNT_PAGE_SIZE)\r\n          .pipe(\r\n            catchError(() => of(null))\r\n          )\r\n          .subscribe((response) => {\r\n            if (!response) {\r\n              return;\r\n            }\r\n            const meetings = mapEventMeetingDetails(\r\n              response?.body?.meetings ?? []\r\n            );\r\n            const total = response?.body?.totalRecords ?? meetings.length;\r\n            const openCount = meetings.filter(\r\n              (meeting) => meeting.isOpenForAttendance\r\n            ).length;\r\n            this.mergeEventCounts(event.eventId, total, openCount);\r\n            this.seedAttendanceStatesFromMeetings(meetings);\r\n          });\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Merges only the meeting counts onto the matching event, leaving its\r\n   * `meetings` rows untouched (used by the eager count prefetch).\r\n   * @param {string} eventId - The event to update.\r\n   * @param {number} totalRecords - The event's total meeting count.\r\n   * @param {number} openForAttendanceCount - The open-for-attendance count.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  private mergeEventCounts(\r\n    eventId: string,\r\n    totalRecords: number,\r\n    openForAttendanceCount: number\r\n  ): void {\r\n    const next = this.upcomingEvents.value.map((event) =>\r\n      event.eventId === eventId\r\n        ? { ...event, meetingCount: totalRecords, openForAttendanceCount }\r\n        : event\r\n    );\r\n    this.upcomingEvents.next(next);\r\n  }\r\n\r\n  /**\r\n   * Builds and posts the `meetingsDetails` request for a single event page,\r\n   * returning the raw response envelope. Shared by {@link loadEventMeetings} and\r\n   * the eager count prefetch.\r\n   * @param {string} eventId - The event whose meetings to fetch.\r\n   * @param {number} page - The one-based page to request.\r\n   * @param {number} size - The page size.\r\n   * @return {Observable<EventMeetingDetailResponse>} The child-meetings response.\r\n   * @memberof DashboardService\r\n   */\r\n  private fetchEventMeetingsPage(\r\n    eventId: string,\r\n    page: number,\r\n    size: number\r\n  ): Observable<EventMeetingDetailResponse> {\r\n    const payload: EventMeetingDetailPayload = {\r\n      payload: {\r\n        eventId,\r\n        sortColumn: EVENT_MEETINGS_SORT_COLUMN,\r\n        ascendingOrder: true,\r\n        page,\r\n        size,\r\n        filter: {\r\n          status: UPCOMING_STATUSES,\r\n          isAllMeetingSelected: false,\r\n        },\r\n      },\r\n    };\r\n    return this.httpService.postData(\r\n      `${this.apiBaseUrl}/meetings/meetingsDetails`,\r\n      payload\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Loads the user's groups, driving the groups section through\r\n   * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on\r\n   * failure. Follows the `pipe(map, catchError(throw))` pattern.\r\n   *\r\n   * TODO: Replace mock with real API call when BE is ready\r\n   * @return {Observable<DashboardListResponse<GroupRow[]>>} The groups response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  loadGroups(): Observable<DashboardListResponse<MyGroupsView>> {\r\n    this.groupsState.next(DashboardSectionState.LOADING);\r\n    return this.httpService\r\n      .getData(`${this.apiBaseUrl}/groups/my-groups`)\r\n      .pipe(\r\n        map((response: DashboardListResponse<MyGroupsView>) => {\r\n          const groups = (response?.body?.groups ?? []).map((group) =>\r\n            this.mapGroup(group)\r\n          );\r\n          this.groups.next(groups);\r\n          this.groupsState.next(\r\n            groups.length > 0\r\n              ? DashboardSectionState.LOADED\r\n              : DashboardSectionState.EMPTY\r\n          );\r\n          return response;\r\n        }),\r\n        catchError((error) => {\r\n          this.groupsState.next(DashboardSectionState.ERROR);\r\n          throw error;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Maps a backend {@link MyGroupView} to the table-facing {@link GroupRow}.\r\n   * Mirrors the My Groups profile tab: the type falls back to \"Unassigned\" when\r\n   * `groupTypeName` is null, affiliations are comma-joined, empty officer role /\r\n   * affiliation render as a placeholder, and a blank member level becomes\r\n   * \"Unassigned\" (rendered as the warning pill by the Your Groups component).\r\n   * @param {MyGroupView} group - The backend group view.\r\n   * @return {GroupRow}\r\n   * @memberof DashboardService\r\n   */\r\n  private mapGroup(group: MyGroupView): GroupRow {\r\n    // The backend returns officer roles as an `officer` array of\r\n    // { officerId, officerName }. Join the names for the Officer Role column\r\n    // (e.g. \"Chair\" or \"Chair, Vice Chair\"); show the placeholder when empty.\r\n    const officerRole =\r\n      (group.officer ?? [])\r\n        .map((officer) => officer?.officerName?.trim())\r\n        .filter((name) => !!name)\r\n        .join(', ') || EMPTY_VALUE;\r\n\r\n    return {\r\n      groupId: group.groupId,\r\n      group: group.groupName,\r\n      type: group.groupTypeName || group.groupType || UNASSIGNED_LABEL,\r\n      officerRole,\r\n      affiliation: group.affiliations?.join(', ') || EMPTY_VALUE,\r\n      memberLevel: group.memberLevel?.trim() || UNASSIGNED_LABEL,\r\n      // Carry the ancestor hierarchy through for the expandable hierarchy rows.\r\n      hierarchy: group.hierarchy ?? [],\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Logs attendance for a meeting. Marks the meeting in-flight (retaining the\r\n   * prior displayed state), posts through `HttpService`, applies the\r\n   * log-attendance-success reducer on success, clears the in-flight flag on\r\n   * completion, and rethrows while retaining prior state on failure.\r\n   * @param {string} meetingId - The meeting to log attendance for.\r\n   * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  logAttendance(\r\n    meetingId: string\r\n  ): Observable<DashboardListResponse<unknown>> {\r\n    this.inFlightMeetingIds.next(\r\n      beginAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n    );\r\n    return this.httpService\r\n      .postData(`${this.apiBaseUrl}/meetings/attendance/log`, { meetingId })\r\n      .pipe(\r\n        map((response) => {\r\n          this.attendanceStates.next(\r\n            applyLogAttendanceSuccess(this.attendanceStates.value, meetingId)\r\n          );\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          return response;\r\n        }),\r\n        catchError((error) => {\r\n          // Retain prior attendance state; only clear the in-flight flag.\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          throw error;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Leaves a meeting. Marks the meeting in-flight (retaining the prior\r\n   * displayed state), posts through `HttpService`, applies the\r\n   * leave-meeting-success reducer on success, clears the in-flight flag on\r\n   * completion, and rethrows while retaining prior state on failure.\r\n   * @param {string} meetingId - The meeting to leave.\r\n   * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.\r\n   * @memberof DashboardService\r\n   */\r\n  leaveMeeting(\r\n    meetingId: string\r\n  ): Observable<DashboardListResponse<unknown>> {\r\n    this.inFlightMeetingIds.next(\r\n      beginAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n    );\r\n    return this.httpService\r\n      .postData(`${this.apiBaseUrl}/meetings/attendance/leave`, { meetingId })\r\n      .pipe(\r\n        map((response) => {\r\n          this.attendanceStates.next(\r\n            applyLeaveMeetingSuccess(this.attendanceStates.value, meetingId)\r\n          );\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          return response;\r\n        }),\r\n        catchError((error) => {\r\n          // Retain prior attendance state; only clear the in-flight flag.\r\n          this.inFlightMeetingIds.next(\r\n            endAttendanceAction(this.inFlightMeetingIds.value, meetingId)\r\n          );\r\n          throw error;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Returns a synchronous snapshot of the per-meeting attendance-state map.\r\n   * @return {Record<string, AttendanceState>} The current attendance-state map.\r\n   * @memberof DashboardService\r\n   */\r\n  getAttendanceStatesSnapshot(): Record<string, AttendanceState> {\r\n    return this.attendanceStates.value;\r\n  }\r\n\r\n  /**\r\n   * Seeds the attendance-state map from a freshly loaded list of events, using\r\n   * each meeting's `attendanceState` (defaulting to `NOT_ATTENDING`). Keeps the\r\n   * displayed state in sync with the data load without overwriting ids that are\r\n   * not present in the new list.\r\n   * @param {UpcomingEvent[]} events - The loaded upcoming events.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  private seedAttendanceStates(events: UpcomingEvent[]): void {\r\n    const meetings = events.flatMap((event) => event.meetings ?? []);\r\n    this.seedAttendanceStatesFromMeetings(meetings);\r\n  }\r\n\r\n  /**\r\n   * Seeds the attendance-state map from a list of meeting rows, using each\r\n   * meeting's `attendanceState` (defaulting to `NOT_ATTENDING`) without\r\n   * overwriting ids absent from the new list. Shared by the list load and the\r\n   * per-event expand so freshly loaded child meetings pick up their state.\r\n   * @param {MeetingRow[]} meetings - The meeting rows to seed from.\r\n   * @return {void}\r\n   * @memberof DashboardService\r\n   */\r\n  private seedAttendanceStatesFromMeetings(meetings: MeetingRow[]): void {\r\n    const next: Record<string, AttendanceState> = {\r\n      ...this.attendanceStates.value,\r\n    };\r\n    meetings.forEach((meeting) => {\r\n      if (meeting.meetingId) {\r\n        next[meeting.meetingId] =\r\n          meeting.attendanceState ??\r\n          next[meeting.meetingId] ??\r\n          AttendanceState.NOT_ATTENDING;\r\n      }\r\n    });\r\n    this.attendanceStates.next(next);\r\n  }\r\n}\r\n"]}

package/esm2022/lib/utils/date-format.util.mjs

@@ -0,0 +1,110 @@
+/**
+ * Pure luxon date/time formatting helpers for the dashboard library.
+ *
+ * The real "events & meetings" backend returns date-times as ISO-8601 strings
+ * (e.g. "2026-01-01T00:00:00") together with a display timezone string
+ * (e.g. "(UTC-04:00) America/New_York"). These helpers parse the ISO value and
+ * render it in the item's own zone (never moment). A numeric epoch-milliseconds
+ * value is also accepted for backward compatibility with fixtures/tests. All
+ * helpers fall back gracefully to an empty string when the value is missing or
+ * unparseable.
+ */
+import { DateTime } from 'luxon';
+/**
+ * Extracts a luxon-usable IANA zone from a backend timezone string such as
+ * "(UTC-04:00) America/New_York" or "America/New_York". Returns `undefined`
+ * when no usable zone can be derived so luxon falls back to the local zone.
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {string | undefined} The IANA zone id, or undefined.
+ */
+export function extractIanaZone(timezone) {
+    if (!timezone) {
+        return undefined;
+    }
+    // Strip a leading "(UTC±HH:MM) " offset prefix when present.
+    const closingParen = timezone.indexOf(') ');
+    const zone = closingParen > -1
+        ? timezone.slice(closingParen + 2).trim()
+        : timezone.trim();
+    return zone.length > 0 ? zone : undefined;
+}
+/**
+ * Parses a backend date-time value — either an ISO-8601 string
+ * (e.g. "2026-01-01T00:00:00") or an epoch-milliseconds number — into a luxon
+ * {@link DateTime} in the supplied timezone. The ISO value is treated as a wall
+ * time in the item's zone so the rendered time matches the backend's intent.
+ * Returns an invalid DateTime when the value is missing/unparseable.
+ * @param {string | number | undefined | null} value - The ISO string or epoch ms.
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {DateTime} The parsed luxon DateTime (may be invalid).
+ */
+export function parseBackendDateTime(value, timezone) {
+    const zone = extractIanaZone(timezone);
+    if (value === undefined || value === null || value === '') {
+        return DateTime.invalid('empty');
+    }
+    if (typeof value === 'number') {
+        return zone
+            ? DateTime.fromMillis(value, { zone })
+            : DateTime.fromMillis(value);
+    }
+    // ISO string: parse as a wall time in the item's zone when known.
+    const isoOptions = zone ? { zone } : {};
+    const parsed = DateTime.fromISO(value, isoOptions);
+    return parsed.isValid ? parsed : DateTime.fromISO(value);
+}
+/**
+ * Formats a backend date-time value (ISO string or epoch ms) with luxon using
+ * the supplied format token, honouring the supplied timezone. Returns an empty
+ * string when the value is missing or invalid.
+ * @param {string | number | undefined | null} value - The ISO string or epoch ms.
+ * @param {string} format - The luxon `toFormat` token.
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {string} The formatted value, or an empty string.
+ */
+export function formatBackendDateTime(value, format, timezone) {
+    const parsed = parseBackendDateTime(value, timezone);
+    return parsed.isValid ? parsed.toFormat(format) : '';
+}
+/**
+ * Backward-compatible alias kept for existing callers. Accepts ISO strings or
+ * epoch ms and formats them in the item's zone.
+ * @param {string | number | undefined | null} value - The ISO string or epoch ms.
+ * @param {string} format - The luxon `toFormat` token.
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {string} The formatted value, or an empty string.
+ */
+export function formatEpoch(value, format, timezone) {
+    return formatBackendDateTime(value, format, timezone);
+}
+/**
+ * Computes a human "Day X of Y" indicator for a multi-day event from its start
+ * and end date-times, relative to "now". Returns an empty string when the dates
+ * are missing/invalid or the event spans a single day.
+ * @param {string | number | undefined | null} start - Event start (ISO or epoch ms).
+ * @param {string | number | undefined | null} end - Event end (ISO or epoch ms).
+ * @param {string | undefined} timezone - The backend timezone string.
+ * @return {string} The "Day X of Y" label, or an empty string.
+ */
+export function computeDayIndicator(start, end, timezone) {
+    const zone = extractIanaZone(timezone);
+    const startDt = parseBackendDateTime(start, timezone);
+    const endDt = parseBackendDateTime(end, timezone);
+    if (!startDt.isValid || !endDt.isValid) {
+        return '';
+    }
+    const startDay = startDt.startOf('day');
+    const endDay = endDt.startOf('day');
+    const totalDays = Math.floor(endDay.diff(startDay, 'days').days) + 1;
+    // Only meaningful for short, multi-day events (a conference-week style span).
+    // Very long spans (e.g. a year-long series) are not shown as "Day X of Y".
+    const MAX_DAY_INDICATOR_SPAN = 31;
+    if (totalDays <= 1 || totalDays > MAX_DAY_INDICATOR_SPAN) {
+        return '';
+    }
+    const now = (zone ? DateTime.now().setZone(zone) : DateTime.now()).startOf('day');
+    const clampedNow = now < startDay ? startDay : now > endDay ? endDay : now;
+    const currentDay = Math.floor(clampedNow.diff(startDay, 'days').days) + 1;
+    return `Day ${currentDay} of ${totalDays}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-format.util.js","sourceRoot":"","sources":["../../../../../projects/dashboard/src/lib/utils/date-format.util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Pure luxon date/time formatting helpers for the dashboard library.\r\n *\r\n * The real \"events & meetings\" backend returns date-times as ISO-8601 strings\r\n * (e.g. \"2026-01-01T00:00:00\") together with a display timezone string\r\n * (e.g. \"(UTC-04:00) America/New_York\"). These helpers parse the ISO value and\r\n * render it in the item's own zone (never moment). A numeric epoch-milliseconds\r\n * value is also accepted for backward compatibility with fixtures/tests. All\r\n * helpers fall back gracefully to an empty string when the value is missing or\r\n * unparseable.\r\n */\r\nimport { DateTime } from 'luxon';\r\n\r\n/**\r\n * Extracts a luxon-usable IANA zone from a backend timezone string such as\r\n * \"(UTC-04:00) America/New_York\" or \"America/New_York\". Returns `undefined`\r\n * when no usable zone can be derived so luxon falls back to the local zone.\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {string | undefined} The IANA zone id, or undefined.\r\n */\r\nexport function extractIanaZone(\r\n  timezone: string | undefined\r\n): string | undefined {\r\n  if (!timezone) {\r\n    return undefined;\r\n  }\r\n  // Strip a leading \"(UTC±HH:MM) \" offset prefix when present.\r\n  const closingParen = timezone.indexOf(') ');\r\n  const zone =\r\n    closingParen > -1\r\n      ? timezone.slice(closingParen + 2).trim()\r\n      : timezone.trim();\r\n  return zone.length > 0 ? zone : undefined;\r\n}\r\n\r\n/**\r\n * Parses a backend date-time value — either an ISO-8601 string\r\n * (e.g. \"2026-01-01T00:00:00\") or an epoch-milliseconds number — into a luxon\r\n * {@link DateTime} in the supplied timezone. The ISO value is treated as a wall\r\n * time in the item's zone so the rendered time matches the backend's intent.\r\n * Returns an invalid DateTime when the value is missing/unparseable.\r\n * @param {string | number | undefined | null} value - The ISO string or epoch ms.\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {DateTime} The parsed luxon DateTime (may be invalid).\r\n */\r\nexport function parseBackendDateTime(\r\n  value: string | number | undefined | null,\r\n  timezone?: string\r\n): DateTime {\r\n  const zone = extractIanaZone(timezone);\r\n  if (value === undefined || value === null || value === '') {\r\n    return DateTime.invalid('empty');\r\n  }\r\n  if (typeof value === 'number') {\r\n    return zone\r\n      ? DateTime.fromMillis(value, { zone })\r\n      : DateTime.fromMillis(value);\r\n  }\r\n  // ISO string: parse as a wall time in the item's zone when known.\r\n  const isoOptions = zone ? { zone } : {};\r\n  const parsed = DateTime.fromISO(value, isoOptions);\r\n  return parsed.isValid ? parsed : DateTime.fromISO(value);\r\n}\r\n\r\n/**\r\n * Formats a backend date-time value (ISO string or epoch ms) with luxon using\r\n * the supplied format token, honouring the supplied timezone. Returns an empty\r\n * string when the value is missing or invalid.\r\n * @param {string | number | undefined | null} value - The ISO string or epoch ms.\r\n * @param {string} format - The luxon `toFormat` token.\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {string} The formatted value, or an empty string.\r\n */\r\nexport function formatBackendDateTime(\r\n  value: string | number | undefined | null,\r\n  format: string,\r\n  timezone?: string\r\n): string {\r\n  const parsed = parseBackendDateTime(value, timezone);\r\n  return parsed.isValid ? parsed.toFormat(format) : '';\r\n}\r\n\r\n/**\r\n * Backward-compatible alias kept for existing callers. Accepts ISO strings or\r\n * epoch ms and formats them in the item's zone.\r\n * @param {string | number | undefined | null} value - The ISO string or epoch ms.\r\n * @param {string} format - The luxon `toFormat` token.\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {string} The formatted value, or an empty string.\r\n */\r\nexport function formatEpoch(\r\n  value: string | number | undefined | null,\r\n  format: string,\r\n  timezone?: string\r\n): string {\r\n  return formatBackendDateTime(value, format, timezone);\r\n}\r\n\r\n/**\r\n * Computes a human \"Day X of Y\" indicator for a multi-day event from its start\r\n * and end date-times, relative to \"now\". Returns an empty string when the dates\r\n * are missing/invalid or the event spans a single day.\r\n * @param {string | number | undefined | null} start - Event start (ISO or epoch ms).\r\n * @param {string | number | undefined | null} end - Event end (ISO or epoch ms).\r\n * @param {string | undefined} timezone - The backend timezone string.\r\n * @return {string} The \"Day X of Y\" label, or an empty string.\r\n */\r\nexport function computeDayIndicator(\r\n  start: string | number | undefined | null,\r\n  end: string | number | undefined | null,\r\n  timezone?: string\r\n): string {\r\n  const zone = extractIanaZone(timezone);\r\n  const startDt = parseBackendDateTime(start, timezone);\r\n  const endDt = parseBackendDateTime(end, timezone);\r\n  if (!startDt.isValid || !endDt.isValid) {\r\n    return '';\r\n  }\r\n  const startDay = startDt.startOf('day');\r\n  const endDay = endDt.startOf('day');\r\n  const totalDays = Math.floor(endDay.diff(startDay, 'days').days) + 1;\r\n  // Only meaningful for short, multi-day events (a conference-week style span).\r\n  // Very long spans (e.g. a year-long series) are not shown as \"Day X of Y\".\r\n  const MAX_DAY_INDICATOR_SPAN = 31;\r\n  if (totalDays <= 1 || totalDays > MAX_DAY_INDICATOR_SPAN) {\r\n    return '';\r\n  }\r\n  const now = (zone ? DateTime.now().setZone(zone) : DateTime.now()).startOf(\r\n    'day'\r\n  );\r\n  const clampedNow = now < startDay ? startDay : now > endDay ? endDay : now;\r\n  const currentDay = Math.floor(clampedNow.diff(startDay, 'days').days) + 1;\r\n  return `Day ${currentDay} of ${totalDays}`;\r\n}\r\n"]}