@ieeesa-npm/dashboard 0.0.0-stage → 0.0.2

package/esm2022/lib/models/event-meeting-list-payload.model.mjs

@@ -0,0 +1,8 @@
+/**
+ * Request payloads for the dashboard "events & meetings" backend calls. These
+ * mirror the `events-and-meetings` library's `GetEventsAndMeetingsPayload` /
+ * `GetMeetingsByEventIdPayload` so the dashboard reuses the exact contract the
+ * existing `view-events-meetings-list` screen posts.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/group-row.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JvdXAtcm93Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGFzaGJvYXJkL3NyYy9saWIvbW9kZWxzL2dyb3VwLXJvdy5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIEEgc2luZ2xlIG5vZGUgaW4gYSBncm91cCdzIGFuY2VzdG9yIGhpZXJhcmNoeSAocm9vdOKGkmxlYWYpLCBhcyByZXR1cm5lZCBieVxyXG4gKiBHRVQgL3YxL2dyb3Vwcy9teS1ncm91cHMuIFVzZWQgdG8gcmVuZGVyIHRoZSBleHBhbmRhYmxlIGhpZXJhcmNoeSByb3dzIGluIHRoZVxyXG4gKiBZb3VyIEdyb3VwcyB0YWJsZS5cclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgR3JvdXBIaWVyYXJjaHlOb2RlIHtcclxuICBncm91cElkOiBzdHJpbmc7XHJcbiAgZ3JvdXBOYW1lOiBzdHJpbmc7XHJcbiAgZ3JvdXBTaG9ydE5hbWU/OiBzdHJpbmc7XHJcbiAgZ3JvdXBBY3JvbnltPzogc3RyaW5nO1xyXG4gIGdyb3VwTGV2ZWw/OiBudW1iZXI7XHJcbiAgZ3JvdXBQYXJlbnRJZD86IHN0cmluZyB8IG51bGw7XHJcbiAgZ3JvdXBUeXBlPzogc3RyaW5nO1xyXG4gIGdyb3VwVHlwZU5hbWU/OiBzdHJpbmcgfCBudWxsO1xyXG4gIGdyb3VwRGVzYz86IHN0cmluZyB8IG51bGw7XHJcbiAgaGFzQ2hpbGRyZW4/OiBib29sZWFuIHwgbnVsbDtcclxufVxyXG5cclxuLyoqXHJcbiAqIFRhYmxlLWZhY2luZyB2aWV3IG9mIGEgZ3JvdXAgaW4gdGhlIFlvdXIgR3JvdXBzIHNlY3Rpb24uIFRoZSBkaXNwbGF5IGZpZWxkc1xyXG4gKiBhcmUgbWFwcGVkIGZyb20gdGhlIGJhY2tlbmQ7IGBoaWVyYXJjaHlgIGNhcnJpZXMgdGhlIGdyb3VwJ3MgYW5jZXN0b3IgcGF0aCBzb1xyXG4gKiB0aGUgcm93IGNhbiBleHBhbmQgdG8gc2hvdyB0aGUgaGllcmFyY2h5IChtYXRjaGluZyB0aGUgTXkgUHJvZmlsZSBGaW5kIEdyb3Vwc1xyXG4gKiB0cmVlKS5cclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgR3JvdXBSb3cge1xyXG4gIGdyb3VwSWQ6IHN0cmluZztcclxuICBncm91cDogc3RyaW5nO1xyXG4gIHR5cGU/OiBzdHJpbmc7XHJcbiAgb2ZmaWNlclJvbGU/OiBzdHJpbmc7XHJcbiAgYWZmaWxpYXRpb24/OiBzdHJpbmc7XHJcbiAgbWVtYmVyTGV2ZWw6IHN0cmluZztcclxuICAvKiogQW5jZXN0b3IgaGllcmFyY2h5IChyb2904oaSbGVhZikgZm9yIHRoZSBleHBhbmRhYmxlIGhpZXJhcmNoeSByb3dzLiAqL1xyXG4gIGhpZXJhcmNoeT86IEdyb3VwSGllcmFyY2h5Tm9kZVtdO1xyXG59XHJcbiJdfQ==

package/esm2022/lib/models/meeting-row.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVldGluZy1yb3cubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kYXNoYm9hcmQvc3JjL2xpYi9tb2RlbHMvbWVldGluZy1yb3cubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEF0dGVuZGFuY2VTdGF0ZSB9IGZyb20gJy4vYXR0ZW5kYW5jZS1zdGF0ZS5tb2RlbCc7XHJcblxyXG4vKipcclxuICogVmlldyBtb2RlbCBmb3IgYSBzaW5nbGUgbWVldGluZyByb3csIHVzZWQgYm90aCBmb3IgYW4gZXZlbnQncyBleHBhbmRlZCBjaGlsZFxyXG4gKiBtZWV0aW5ncyBhbmQgKHZpYSB7QGxpbmsgVXBjb21pbmdFdmVudH0pIGZvciBzdGFuZGFsb25lIG1lZXRpbmcgY2FyZHMuXHJcbiAqXHJcbiAqIGBzdGFydEVwb2NoTXNgIC8gYGVuZEVwb2NoTXNgIGNhcnJ5IHRoZSByYXcgZXBvY2gtbWlsbGlzZWNvbmRzIHZhbHVlcyBmcm9tIHRoZVxyXG4gKiBiYWNrZW5kIGFuZCBhcmUgZm9ybWF0dGVkIHdpdGggbHV4b24gYERhdGVUaW1lLmZyb21NaWxsaXNgLiBUaGUgbGVnYWN5IElTT1xyXG4gKiBgbWVldGluZ0RhdGVgIC8gYG1lZXRpbmdUaW1lYCBmaWVsZHMgYXJlIHJldGFpbmVkIGZvciBleGlzdGluZyBmaXh0dXJlcy90ZXN0cy5cclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgTWVldGluZ1JvdyB7XHJcbiAgbWVldGluZ0lkOiBzdHJpbmc7XHJcbiAgbWVldGluZ05hbWU6IHN0cmluZztcclxuICBncm91cE9yQ29tbWl0dGVlPzogc3RyaW5nO1xyXG4gIHJvb21PckxvY2F0aW9uPzogc3RyaW5nO1xyXG4gIC8qKiBTdGFydCBkYXRlLXRpbWUgYXMgYW4gSVNPLTg2MDEgc3RyaW5nIChvciBlcG9jaCBtcyBmb3IgZml4dHVyZXMpLiAqL1xyXG4gIHN0YXJ0RGF0ZVRpbWU/OiBzdHJpbmcgfCBudW1iZXI7XHJcbiAgLyoqIEVuZCBkYXRlLXRpbWUgYXMgYW4gSVNPLTg2MDEgc3RyaW5nIChvciBlcG9jaCBtcyBmb3IgZml4dHVyZXMpLiAqL1xyXG4gIGVuZERhdGVUaW1lPzogc3RyaW5nIHwgbnVtYmVyO1xyXG4gIC8qKiBMZWdhY3kgSVNPIG1lZXRpbmcgZGF0ZSwgcmV0YWluZWQgZm9yIGZpeHR1cmVzL3Rlc3RzLiAqL1xyXG4gIG1lZXRpbmdEYXRlPzogc3RyaW5nO1xyXG4gIC8qKiBMZWdhY3kgSVNPIG1lZXRpbmcgdGltZSwgcmV0YWluZWQgZm9yIGZpeHR1cmVzL3Rlc3RzLiAqL1xyXG4gIG1lZXRpbmdUaW1lPzogc3RyaW5nO1xyXG4gIHRpbWV6b25lOiBzdHJpbmc7XHJcbiAgc3RhdHVzPzogc3RyaW5nO1xyXG4gIGlzTWVtYmVyT2ZHcm91cD86IGJvb2xlYW47XHJcbiAgaXNPcGVuRm9yQXR0ZW5kYW5jZT86IGJvb2xlYW47XHJcbiAgYXR0ZW5kYW5jZVN0YXRlPzogQXR0ZW5kYW5jZVN0YXRlO1xyXG59XHJcbiJdfQ==

package/esm2022/lib/models/my-groups-view.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/page-change.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnZS1jaGFuZ2UubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kYXNoYm9hcmQvc3JjL2xpYi9tb2RlbHMvcGFnZS1jaGFuZ2UubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUGFnZUNoYW5nZSB7XHJcbiAgcGFnZUluZGV4OiBudW1iZXI7XHJcbiAgcGFnZVNpemU6IG51bWJlcjtcclxufVxyXG4iXX0=

package/esm2022/lib/models/upcoming-event.model.mjs

@@ -0,0 +1,13 @@
+/* eslint-disable no-unused-vars */
+/**
+ * Discriminates how a row in the "Upcoming Meetings & Events" list is rendered.
+ * EVENT rows render as an expandable event block that owns child meetings;
+ * STANDALONE_MEETING rows render as a single meeting card and always sort LAST
+ * within the list.
+ */
+export var UpcomingItemKind;
+(function (UpcomingItemKind) {
+    UpcomingItemKind["EVENT"] = "EVENT";
+    UpcomingItemKind["STANDALONE_MEETING"] = "STANDALONE_MEETING";
+})(UpcomingItemKind || (UpcomingItemKind = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/attendance-reducers.mjs

@@ -0,0 +1,54 @@
+import { AttendanceState } from '../models/attendance-state.model';
+/**
+ * Pure reducers for the dashboard attendance state. These functions never
+ * mutate their inputs; each returns a new object/set so they can be exercised
+ * directly by property tests and composed by the DashboardService.
+ */
+/**
+ * Produce a new attendance-state map with the target meeting set to
+ * CURRENTLY_ATTENDING. Every other entry is copied unchanged (frame property).
+ *
+ * @param {Record<string, AttendanceState>} map The current attendance-state map (not mutated).
+ * @param {string} meetingId The meeting whose state transitions to CURRENTLY_ATTENDING.
+ * @return {Record<string, AttendanceState>} A new map reflecting the successful log-attendance action.
+ */
+export const applyLogAttendanceSuccess = (map, meetingId) => ({
+    ...map,
+    [meetingId]: AttendanceState.CURRENTLY_ATTENDING,
+});
+/**
+ * Produce a new attendance-state map with the target meeting set to
+ * NOT_ATTENDING. Every other entry is copied unchanged (frame property).
+ *
+ * @param {Record<string, AttendanceState>} map The current attendance-state map (not mutated).
+ * @param {string} meetingId The meeting whose state transitions to NOT_ATTENDING.
+ * @return {Record<string, AttendanceState>} A new map reflecting the successful leave-meeting action.
+ */
+export const applyLeaveMeetingSuccess = (map, meetingId) => ({
+    ...map,
+    [meetingId]: AttendanceState.NOT_ATTENDING,
+});
+/**
+ * Add a meeting to the in-flight set, returning a new set. Prior membership is
+ * retained so the displayed attendance state is preserved while the request
+ * resolves.
+ *
+ * @param {ReadonlySet<string>} set The current in-flight meeting-id set (not mutated).
+ * @param {string} meetingId The meeting whose attendance action has started.
+ * @return {Set<string>} A new set that additionally contains the meeting id.
+ */
+export const beginAttendanceAction = (set, meetingId) => new Set([...set, meetingId]);
+/**
+ * Remove a meeting from the in-flight set, returning a new set. All other
+ * in-flight ids are retained.
+ *
+ * @param {ReadonlySet<string>} set The current in-flight meeting-id set (not mutated).
+ * @param {string} meetingId The meeting whose attendance action has resolved.
+ * @return {Set<string>} A new set that no longer contains the meeting id.
+ */
+export const endAttendanceAction = (set, meetingId) => {
+    const next = new Set(set);
+    next.delete(meetingId);
+    return next;
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,402 @@
+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 { 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`
+ * service conventions: it is a `providedIn: 'root'` singleton, holds the host
+ * `apiBaseUrl` / `userPermissions` set via {@link setAppConfig}, owns its state
+ * via `BehaviorSubject`s exposed as observables, and reaches the backend only
+ * through the shared `HttpService` from `@ieeesa-npm/utility` (never
+ * `HttpClient` directly).
+ *
+ * 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
+ */
+export class DashboardService {
+    constructor(
+    // eslint-disable-next-line no-unused-vars
+    httpService // eslint-disable-next-line no-empty-function
+    ) {
+        this.httpService = httpService;
+        this.upcomingEvents = new BehaviorSubject([]);
+        this.groups = new BehaviorSubject([]);
+        this.upcomingState = new BehaviorSubject(DashboardSectionState.LOADING);
+        this.groupsState = new BehaviorSubject(DashboardSectionState.LOADING);
+        this.attendanceStates = new BehaviorSubject({});
+        this.inFlightMeetingIds = new BehaviorSubject(new Set());
+        /** Emits the list of the user's upcoming events. */
+        this.upcomingEvents$ = this.upcomingEvents.asObservable();
+        /** Emits the list of the user's groups. */
+        this.groups$ = this.groups.asObservable();
+        /** Emits the load/empty/error state of the upcoming-events section. */
+        this.upcomingState$ = this.upcomingState.asObservable();
+        /** Emits the load/empty/error state of the groups section. */
+        this.groupsState$ = this.groupsState.asObservable();
+        /** Emits the per-meeting attendance-state map. */
+        this.attendanceStates$ = this.attendanceStates.asObservable();
+        /** Emits the set of meeting ids with an attendance action in flight. */
+        this.inFlightMeetingIds$ = this.inFlightMeetingIds.asObservable();
+    }
+    /**
+     * Stores the host-supplied API base URL and user permissions used to build
+     * request URLs and gate permission-controlled actions. Mirrors the
+     * `events-and-meetings` service `setAppConfig`.
+     * @param {string} apiBaseURL - The host application's API base URL.
+     * @param {UserPermission[]} userPermissions - The signed-in user's permissions.
+     * @return {void}
+     * @memberof DashboardService
+     */
+    setAppConfig(apiBaseURL, userPermissions) {
+        this.apiBaseUrl = apiBaseURL;
+        this.userPermissions = userPermissions;
+    }
+    /**
+     * 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);
+        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
+     * failure. Follows the `pipe(map, catchError(throw))` pattern.
+     *
+     * TODO: Replace mock with real API call when BE is ready
+     * @return {Observable<DashboardListResponse<GroupRow[]>>} The groups response envelope.
+     * @memberof DashboardService
+     */
+    loadGroups() {
+        this.groupsState.next(DashboardSectionState.LOADING);
+        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
+                : DashboardSectionState.EMPTY);
+            return response;
+        }), catchError((error) => {
+            this.groupsState.next(DashboardSectionState.ERROR);
+            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
+     * log-attendance-success reducer on success, clears the in-flight flag on
+     * completion, and rethrows while retaining prior state on failure.
+     * @param {string} meetingId - The meeting to log attendance for.
+     * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.
+     * @memberof DashboardService
+     */
+    logAttendance(meetingId) {
+        this.inFlightMeetingIds.next(beginAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+        return this.httpService
+            .postData(`${this.apiBaseUrl}/meetings/attendance/log`, { meetingId })
+            .pipe(map((response) => {
+            this.attendanceStates.next(applyLogAttendanceSuccess(this.attendanceStates.value, meetingId));
+            this.inFlightMeetingIds.next(endAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+            return response;
+        }), catchError((error) => {
+            // Retain prior attendance state; only clear the in-flight flag.
+            this.inFlightMeetingIds.next(endAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+            throw error;
+        }));
+    }
+    /**
+     * Leaves a meeting. Marks the meeting in-flight (retaining the prior
+     * displayed state), posts through `HttpService`, applies the
+     * leave-meeting-success reducer on success, clears the in-flight flag on
+     * completion, and rethrows while retaining prior state on failure.
+     * @param {string} meetingId - The meeting to leave.
+     * @return {Observable<DashboardListResponse<unknown>>} The attendance response envelope.
+     * @memberof DashboardService
+     */
+    leaveMeeting(meetingId) {
+        this.inFlightMeetingIds.next(beginAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+        return this.httpService
+            .postData(`${this.apiBaseUrl}/meetings/attendance/leave`, { meetingId })
+            .pipe(map((response) => {
+            this.attendanceStates.next(applyLeaveMeetingSuccess(this.attendanceStates.value, meetingId));
+            this.inFlightMeetingIds.next(endAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+            return response;
+        }), catchError((error) => {
+            // Retain prior attendance state; only clear the in-flight flag.
+            this.inFlightMeetingIds.next(endAttendanceAction(this.inFlightMeetingIds.value, meetingId));
+            throw error;
+        }));
+    }
+    /**
+     * Returns a synchronous snapshot of the per-meeting attendance-state map.
+     * @return {Record<string, AttendanceState>} The current attendance-state map.
+     * @memberof DashboardService
+     */
+    getAttendanceStatesSnapshot() {
+        return this.attendanceStates.value;
+    }
+    /**
+     * Seeds the attendance-state map from a freshly loaded list of events, using
+     * each meeting's `attendanceState` (defaulting to `NOT_ATTENDING`). Keeps the
+     * displayed state in sync with the data load without overwriting ids that are
+     * not present in the new list.
+     * @param {UpcomingEvent[]} events - The loaded upcoming events.
+     * @return {void}
+     * @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,
+        };
+        meetings.forEach((meeting) => {
+            if (meeting.meetingId) {
+                next[meeting.meetingId] =
+                    meeting.attendanceState ??
+                        next[meeting.meetingId] ??
+                        AttendanceState.NOT_ATTENDING;
+            }
+        });
+        this.attendanceStates.next(next);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DashboardService, deps: [{ token: i1.HttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DashboardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DashboardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    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 {\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"]}