@ieeesa-npm/dashboard 0.0.2 → 0.0.4

package/lib/models/event-meeting-list-item.model.d.ts

@@ -1,25 +1,25 @@
+import { AttendanceState } from './attendance-state.model';
 /**
- * Raw list item returned by the real "events & meetings" backend
- * (`POST {apiBaseUrl}/meetings/eventsAndMeetings`). A single list may contain
- * both EVENT rows (`isMeetingEvent === true` / `hasChildren === true`, which own
- * child meetings) and STANDALONE MEETING rows (`isMeetingEvent === false`).
+ * Raw combined list item returned by the home events-&-meetings endpoint
+ * (`POST {apiBaseUrl}/meetings/home/eventsAndMeetings`). A single list contains
+ * both EVENT rows (`isMeetingEvent === true`, which own child meetings) and
+ * STANDALONE MEETING rows (`isMeetingEvent === false`).
  *
- * Dates are epoch milliseconds (not ISO strings) and must be formatted with
- * luxon `DateTime.fromMillis`. This shape mirrors the `events-and-meetings`
- * library's `EventsAndMeetings` list model so the dashboard reuses the exact
- * backend contract referenced by the existing
- * `view-events-meetings-list` screen.
+ * Dates are ISO-8601 strings (e.g. "2026-09-19T09:00:00"). Row-type fields are
+ * omitted (NON_NULL) when not applicable:
+ * - EVENT rows carry {@link totalMeetingCount} / {@link meetingsOpenForAttendanceCount}; no `attendanceState`.
+ * - STANDALONE rows carry {@link attendanceState}; no event counts.
  */
 export interface EventMeetingListItem {
     /** Stable identifier of the event or standalone meeting. */
     id: string;
     /** Event / meeting display name. */
     name: string;
-    /** Start date-time as an ISO-8601 string (or epoch ms for legacy fixtures). */
-    startDateTime: string | number;
-    /** End date-time as an ISO-8601 string (or epoch ms for legacy fixtures). */
-    endDateTime: string | number;
-    /** IANA / offset-prefixed timezone string, e.g. "(UTC+05:30) Asia/Kolkata". */
+    /** Start date-time as an ISO-8601 string. */
+    startDateTime: string;
+    /** End date-time as an ISO-8601 string. */
+    endDateTime: string;
+    /** IANA timezone string, e.g. "Asia/Kolkata". */
     timeZone: string;
     /** Owning group id. */
     groupId?: string;
@@ -27,81 +27,81 @@ export interface EventMeetingListItem {
     groupName?: string;
     /** Owning group acronym, when provided. */
     groupAcronym?: string;
-    /** Room / location text, when provided. */
+    /** Room / location text, when provided (null for virtual/none). */
     meetingLocation?: string | null;
     /** True when this row is an EVENT that owns child meetings. */
     hasChildren?: boolean;
-    /**
-     * True when the row represents an EVENT (vs. a standalone meeting). Combined
-     * with {@link hasChildren} this is the EVENT-vs-STANDALONE discriminator.
-     */
-    isMeetingEvent?: boolean;
-    /** Lifecycle status, e.g. "In Progress", "Upcoming", "Starts Soon". */
+    /** True when the row represents an EVENT (vs. a standalone meeting). */
+    isMeetingEvent: boolean;
+    /** Lifecycle status, e.g. "In Progress", "Upcoming", "Completed". */
     status?: string;
-    /** True when the signed-in user is a member of the owning group. */
-    isMemberOfGroup?: boolean;
-    /** True when the current user is currently attending (drives the pill). */
-    isCurrentlyAttending?: boolean;
-    /** True when the row is open for attendance logging. */
-    isOpenForAttendance?: boolean;
-    /** Event id a standalone/child meeting belongs to, when applicable. */
-    eventId?: string;
-    /** Meeting id, when the row is a meeting. */
-    meetingId?: string;
-    /** Alternate name key some payloads use for meetings. */
-    meetingTitle?: string;
-    /** Alternate status key (the list screen copies status here). */
-    contentUnderLink?: string;
-    /** Alternate location key used by some meeting payloads. */
-    room?: string | null;
-    /** Count of child meetings for an event, when the backend provides it. */
-    meetingCount?: number;
-    /** Count of child meetings open for attendance, when provided. */
-    openForAttendanceCount?: number;
-    /** "Day X of Y" indicator string, when the backend provides it. */
-    dayIndicator?: string;
+    registeredParticipants?: boolean;
+    hasAttendanceRecords?: boolean;
+    registrationRequired?: boolean;
+    registrationLink?: string | null;
+    creditEnabled?: boolean;
+    /** EVENT only: total active meetings in the event. */
+    totalMeetingCount?: number;
+    /** EVENT only: meetings upcoming/in-progress AND attendance-enabled. */
+    meetingsOpenForAttendanceCount?: number;
+    /** STANDALONE only: the user's attendance state for this meeting. */
+    attendanceState?: AttendanceState;
 }
-/**
- * Response envelope for the dashboard events-&-meetings list endpoint, matching
- * the `events-and-meetings` library's `GetEventsAndMeetingsResponse` body shape.
- */
+/** Body of the home events-&-meetings list response. */
+export interface EventMeetingListBody {
+    totalRecords: number;
+    eventMeetingList: EventMeetingListItem[];
+}
+/** Response envelope for the home events-&-meetings list endpoint. */
 export interface EventMeetingListResponse {
     status: boolean;
     message?: string;
-    body: {
-        totalRecords: number;
-        eventMeetingList: EventMeetingListItem[];
-    };
+    body: EventMeetingListBody;
 }
 /**
- * Child-meeting list item returned by the per-event expand endpoint
- * (`POST {apiBaseUrl}/meetings/meetingsDetails`). Dates are epoch milliseconds.
- * Mirrors the `events-and-meetings` library's `Meeting` model.
+ * Child-meeting item returned by the per-event drill-down endpoint
+ * (`POST {apiBaseUrl}/meetings/home/events/{eventId}/meetings`). Dates are
+ * ISO-8601 strings. `location` follows the backend rule (physical location, else
+ * "Virtual" when a virtual URL exists, else null).
  */
 export interface EventMeetingDetailItem {
     meetingId: string;
     meetingTitle: string;
-    meetingStDate: string | number;
-    meetingEdDate: string | number;
-    meetingLocation?: string;
     groupId?: string;
     groupName?: string;
     groupAcronym?: string;
+    location?: string | null;
+    meetingStDate: string;
+    meetingEdDate: string;
     timeZone?: string;
     status?: string;
-    isMemberOfGroup?: boolean;
-    isCurrentlyAttending?: boolean;
-    isOpenForAttendance?: boolean;
+    attendanceState?: AttendanceState;
 }
-/**
- * Response envelope for the per-event child-meetings expand endpoint, matching
- * the `events-and-meetings` library's `GetMeetingsByEventIdResponse` body shape.
- */
+/** Body of the per-event drill-down response. */
+export interface EventMeetingDetailBody {
+    eventId: string;
+    eventName: string;
+    status: string;
+    /** Current day index for the "Day X of Y" display. */
+    currentDay: number;
+    /** Total day span for the "Day X of Y" display. */
+    totalDays: number;
+    startDate: string;
+    endDate: string;
+    timeZone: string;
+    /** All active meetings in the event. */
+    totalMeetingCount: number;
+    /** Upcoming/in-progress AND attendance-enabled meetings. */
+    meetingsOpenForAttendanceCount: number;
+    /** Count of the user's tied upcoming meetings for this event (paginator length). */
+    totalRecords: number;
+    page: number;
+    size: number;
+    meetings: EventMeetingDetailItem[];
+}
+/** Response envelope for the per-event drill-down endpoint. */
 export interface EventMeetingDetailResponse {
     status: boolean;
     message?: string;
-    body: {
-        totalRecords: number;
-        meetings: EventMeetingDetailItem[];
-    };
+    body: EventMeetingDetailBody;
 }

package/lib/models/event-meeting-list-payload.model.d.ts

@@ -1,40 +1,29 @@
 /**
- * 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.
+ * Request payloads for the dashboard "home" events-&-meetings backend calls.
+ *
+ * `appId` is taken from the JWT, so it is never sent. `page` / `size` are
+ * required; `sortColumn` / `ascendingOrder` / `searchTerm` are optional on the
+ * list endpoint (the service always orders by start date asc, then name asc;
+ * `searchTerm`, when present, must be at least 3 characters).
  */
-/** Filter block shared by the list and expand payloads. */
-export interface EventMeetingFilter {
-    /** Lifecycle statuses to include, e.g. ["In Progress", "Upcoming"]. */
-    status: string[];
-    /** Whether every meeting (regardless of membership) should be returned. */
-    isAllMeetingSelected: boolean;
-    /** Optional group-id scope. */
-    groupIds?: string[];
-}
-/** Payload for `POST {apiBaseUrl}/meetings/eventsAndMeetings` (the section list). */
+/** Payload for `POST {apiBaseUrl}/meetings/home/eventsAndMeetings` (the section list). */
 export interface EventMeetingListPayload {
     payload: {
-        /** Null for the top-level list; an event id when scoping to one event. */
-        eventId: string | null;
-        sortColumn: string;
-        ascendingOrder: boolean;
         page: number;
         size: number;
+        sortColumn?: string;
+        ascendingOrder?: boolean;
         searchTerm?: string | null;
-        filter: EventMeetingFilter;
     };
 }
-/** Payload for `POST {apiBaseUrl}/meetings/meetingsDetails` (per-event expand). */
+/**
+ * Payload for `POST {apiBaseUrl}/meetings/home/events/{eventId}/meetings`
+ * (per-event drill-down). The `eventId` is in the URL path, not the body; only
+ * `page` / `size` are used.
+ */
 export interface EventMeetingDetailPayload {
     payload: {
-        eventId: string;
-        sortColumn: string;
-        ascendingOrder: boolean;
         page: number;
         size: number;
-        searchTerm?: string | null;
-        filter: EventMeetingFilter;
     };
 }

package/lib/models/meeting-row.model.d.ts

@@ -9,6 +9,8 @@ import { AttendanceState } from './attendance-state.model';
  */
 export interface MeetingRow {
     meetingId: string;
+    /** Owning event id, used to build the view-meeting navigation URL. */
+    eventId?: string;
     meetingName: string;
     groupOrCommittee?: string;
     roomOrLocation?: string;

package/lib/models/upcoming-event.model.d.ts

@@ -1,3 +1,4 @@
+import { AttendanceState } from './attendance-state.model';
 import { MeetingRow } from './meeting-row.model';
 /**
  * Discriminates how a row in the "Upcoming Meetings & Events" list is rendered.
@@ -30,6 +31,12 @@ export interface UpcomingEvent {
     status: string;
     dayIndicator?: string;
     meetingCount: number;
+    /**
+     * Paginator length for the drill-down meeting list — the count of the user's
+     * tied upcoming meetings for this event (a subset of {@link meetingCount}).
+     * Populated by the drill-down response; defaults to `meetingCount`.
+     */
+    meetingPageTotal?: number;
     openForAttendanceCount: number;
     /** Start date-time as an ISO-8601 string (or epoch ms for fixtures). */
     startDateTime?: string | number;
@@ -46,6 +53,8 @@ export interface UpcomingEvent {
     roomOrLocation?: string;
     /** True when the user is a member of the owning group. */
     isMemberOfGroup?: boolean;
+    /** STANDALONE only: the user's attendance state for this meeting. */
+    attendanceState?: AttendanceState;
     /** The event's child meetings (empty / lazily loaded for EVENT rows). */
     meetings: MeetingRow[];
 }

package/lib/services/dashboard.service.d.ts

@@ -61,75 +61,47 @@ export declare class DashboardService {
      */
     setAppConfig(apiBaseURL: string, userPermissions: UserPermission[]): void;
     /**
-     * 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.
+     * Loads the user's combined upcoming events & standalone meetings from the
+     * backend via `POST {apiBaseUrl}/meetings/home/eventsAndMeetings`. The response
+     * (which carries per-event `totalMeetingCount` / `meetingsOpenForAttendanceCount`
+     * and per-standalone `attendanceState` directly) is mapped into the dashboard
+     * view models (STANDALONE_MEETING rows ordered last), the per-meeting
+     * attendance-state map is seeded, and the section advances through
+     * LOADING → LOADED/EMPTY on success. `appId` is taken from the JWT, so it is
+     * not sent. Follows the shared `pipe(map, catchError(throw))` pattern.
+     * @return {Observable<EventMeetingListResponse>} The home events-&-meetings response envelope.
      * @memberof DashboardService
      */
     loadUpcomingEvents(): Observable<EventMeetingListResponse>;
     /**
-     * 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.
+     * Lazily loads (and paginates) the child meetings of an EVENT via
+     * `POST {apiBaseUrl}/meetings/home/events/{eventId}/meetings` (the drill-down
+     * endpoint). The `eventId` is sent in the URL path; only `page` / `size` are
+     * used in the body. On success the drill-down body (day indicator, counts,
+     * paginator total, and the paged meetings) is merged onto the matching event,
+     * 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.
+     * @return {Observable<EventMeetingDetailResponse>} The drill-down response envelope.
      * @memberof DashboardService
      */
     loadEventMeetings(eventId: string, page?: number, size?: number): Observable<EventMeetingDetailResponse>;
     /**
-     * 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.
+     * Merges a freshly loaded drill-down page onto the matching event in the
+     * `upcomingEvents` list: the paged `meetings`, the paginator total
+     * (`totalRecords` = the user's tied upcoming meetings), the event's full
+     * `totalMeetingCount` / `meetingsOpenForAttendanceCount`, and the
+     * "Day X of Y" indicator derived from `currentDay` / `totalDays`. 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.
+     * @param {MeetingRow[]} meetings - The mapped drill-down meetings for the page.
+     * @param {EventMeetingDetailBody | undefined} body - The drill-down response body.
      * @return {void}
      * @memberof DashboardService
      */
     private mergeEventMeetings;
-    /**
-     * 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
-     */
-    private loadEventCounts;
-    /**
-     * 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
-     */
-    private mergeEventCounts;
-    /**
-     * 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
-     */
-    private fetchEventMeetingsPage;
     /**
      * Loads the user's groups, driving the groups section through
      * LOADING → LOADED/EMPTY on success and leaving the caller to set ERROR on

package/lib/services/user-permissions.service.d.ts

@@ -2,9 +2,10 @@ import { UserPermission } from '@ieeesa-npm/models';
 import { AttendanceActionPermissions } from '../models/attendance-action-permissions.model';
 import * as i0 from "@angular/core";
 /**
- * Permission identifiers (by name) that gate the dashboard attendance actions.
- * Mirrors the permission-type pattern used by the `events-and-meetings` and
- * `groups` user-permissions services.
+ * Permission display names that gate the dashboard attendance actions. These
+ * match the local demo mock. The real backend grants attendance capability via
+ * a permission id (see {@link ATTENDANCE_PERMISSION_IDS}) rather than these
+ * display names, so both are accepted.
  */
 export declare enum DashboardPermissionType {
     LOG_ATTENDANCE = "Log Attendance",
@@ -12,7 +13,10 @@ export declare enum DashboardPermissionType {
 }
 export declare class UserPermissionsService {
     /**
-     * Returns access provision for the passed action/feature based on whether the signed in user has appropriate permission.
+     * Returns access provision for the passed action/feature based on whether the
+     * signed-in user has an appropriate permission — matched by the legacy display
+     * name (used by the local demo mock) OR by one of the real backend permission
+     * ids in {@link ATTENDANCE_PERMISSION_IDS}.
      * @param {DashboardPermissionType} permission
      * @param {UserPermission[]} userPermissions
      * @return {boolean}

package/lib/utils/event-meeting-mapper.util.d.ts

@@ -1,50 +1,44 @@
-/**
- * Pure mappers converting the raw "events & meetings" backend list/detail items
- * into the dashboard view models. No Angular / service dependencies so they are
- * trivially unit-testable and shared by {@link DashboardService}.
- *
- * Backend dates are epoch milliseconds; callers format them with luxon
- * `DateTime.fromMillis` at render time. The list mapper enforces the dashboard
- * rule that STANDALONE_MEETING rows always sort LAST within the section.
- */
 import { EventMeetingDetailItem, EventMeetingListItem } from '../models/event-meeting-list-item.model';
 import { MeetingRow } from '../models/meeting-row.model';
 import { UpcomingEvent, UpcomingItemKind } from '../models/upcoming-event.model';
 /**
  * Determines whether a raw list item is an EVENT (owns child meetings) or a
- * STANDALONE_MEETING. An item is an EVENT when the backend flags it with
- * `isMeetingEvent === true` or `hasChildren === true`.
+ * STANDALONE_MEETING, using the backend `isMeetingEvent` discriminator (falling
+ * back to `hasChildren`).
  * @param {EventMeetingListItem} item - The raw list item.
  * @return {UpcomingItemKind} The resolved render kind.
  */
 export declare function resolveItemKind(item: EventMeetingListItem): UpcomingItemKind;
 /**
  * Maps a raw backend list item to the {@link UpcomingEvent} view model. EVENT
- * rows start with an empty `meetings` array (child meetings are lazily loaded on
- * expand); STANDALONE_MEETING rows carry their own group/location fields.
+ * rows carry their total / open-for-attendance counts and start with an empty
+ * `meetings` array (child meetings are lazily loaded on drill-down);
+ * STANDALONE_MEETING rows carry their own group/location + attendance state.
  * @param {EventMeetingListItem} item - The raw list item.
  * @return {UpcomingEvent} The mapped view model.
  */
 export declare function mapListItemToUpcomingEvent(item: EventMeetingListItem): UpcomingEvent;
 /**
- * Maps a raw backend list of events & meetings into the dashboard view models,
- * enforcing that STANDALONE_MEETING rows always sort LAST while preserving the
- * backend's within-group ordering for each partition (stable sort).
+ * Maps a raw backend combined list into the dashboard view models, enforcing
+ * that STANDALONE_MEETING rows always sort LAST while preserving the backend's
+ * within-group ordering for each partition (stable sort).
  * @param {EventMeetingListItem[]} items - The raw list items.
  * @return {UpcomingEvent[]} The mapped, standalone-last ordered view models.
  */
 export declare function mapEventMeetingList(items: EventMeetingListItem[]): UpcomingEvent[];
 /**
- * Maps a raw backend child-meeting detail item to the {@link MeetingRow} view
+ * Maps a raw backend drill-down meeting item to the {@link MeetingRow} view
  * model used by the event block's expanded meeting list.
  * @param {EventMeetingDetailItem} item - The raw child-meeting item.
+ * @param {string} [eventId] - The owning event id (for navigation).
  * @return {MeetingRow} The mapped meeting row.
  */
-export declare function mapDetailItemToMeetingRow(item: EventMeetingDetailItem): MeetingRow;
+export declare function mapDetailItemToMeetingRow(item: EventMeetingDetailItem, eventId?: string): MeetingRow;
 /**
- * Maps a raw backend list of child-meeting detail items to {@link MeetingRow}
- * view models.
+ * Maps a raw backend drill-down meeting list to {@link MeetingRow} view models,
+ * tagging each with its owning event id for navigation.
  * @param {EventMeetingDetailItem[]} items - The raw child-meeting items.
+ * @param {string} [eventId] - The owning event id.
  * @return {MeetingRow[]} The mapped meeting rows.
  */
-export declare function mapEventMeetingDetails(items: EventMeetingDetailItem[]): MeetingRow[];
+export declare function mapEventMeetingDetails(items: EventMeetingDetailItem[], eventId?: string): MeetingRow[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ieeesa-npm/dashboard",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "peerDependencies": {
     "@angular/common": "^16.1.0",
     "@angular/core": "^16.1.0",