@jmruthers/pace-core 0.5.68 → 0.5.69

package/src/services/EventService.ts

@@ -0,0 +1,366 @@
+/**
+ * @file Event Service
+ * @package @jmruthers/pace-core
+ * @module Services
+ * @since 0.1.0
+ *
+ * Event service implementation.
+ * Handles event management and selection with organisation context validation.
+ */
+
+import { BaseService } from './base/BaseService';
+import { IEventService } from './interfaces/IEventService';
+import { Event } from '../types/unified';
+import { DebugLogger } from '../utils/debugLogger';
+
+export class EventService extends BaseService implements IEventService {
+  private events: Event[] = [];
+  private selectedEvent: Event | null = null;
+  private _isLoading = true;
+  private error: Error | null = null;
+
+  // Dependencies
+  private supabaseClient: any = null;
+  private user: any = null;
+  private session: any = null;
+  private appName: string = '';
+  private selectedOrganisation: any = null;
+  private setSelectedEventId: ((eventId: string | null) => void) | null = null;
+
+  // Internal state management
+  private isInitializedRef = false;
+  private isFetchingRef = false;
+  private hasAutoSelectedRef = false;
+  private userClearedEventRef = false;
+
+  constructor(
+    supabaseClient: any,
+    user: any,
+    session: any,
+    appName: string,
+    selectedOrganisation: any,
+    setSelectedEventId: (eventId: string | null) => void
+  ) {
+    super();
+    this.supabaseClient = supabaseClient;
+    this.user = user;
+    this.session = session;
+    this.appName = appName;
+    this.selectedOrganisation = selectedOrganisation;
+    this.setSelectedEventId = setSelectedEventId;
+  }
+
+  // Update dependencies
+  updateDependencies(
+    supabaseClient: any,
+    user: any,
+    session: any,
+    appName: string,
+    selectedOrganisation: any,
+    setSelectedEventId: (eventId: string | null) => void
+  ): void {
+    this.supabaseClient = supabaseClient;
+    this.user = user;
+    this.session = session;
+    this.appName = appName;
+    this.selectedOrganisation = selectedOrganisation;
+    this.setSelectedEventId = setSelectedEventId;
+    this.notify();
+  }
+
+  // Event state getters
+  getEvents(): Event[] {
+    return this.events;
+  }
+
+  getSelectedEvent(): Event | null {
+    return this.selectedEvent;
+  }
+
+  isLoading(): boolean {
+    return this._isLoading;
+  }
+
+  getError(): Error | null {
+    return this.error;
+  }
+
+  // Event methods
+  setSelectedEvent(event: Event | null): void {
+    if (event) {
+      // SECURITY: Validate event belongs to current organisation
+      try {
+        console.log('[EventService] Event selection validation:', {
+          eventId: event.event_id,
+          eventName: event.event_name,
+          eventOrganisationId: event.organisation_id,
+          selectedOrganisationId: this.selectedOrganisation?.id,
+          selectedOrganisationName: this.selectedOrganisation?.display_name,
+          match: event.organisation_id === this.selectedOrganisation?.id
+        });
+        
+        if (this.selectedOrganisation && event.organisation_id !== this.selectedOrganisation.id) {
+          console.error('[EventService] Event organisation_id does not match selected organisation', {
+            eventOrganisationId: event.organisation_id,
+            selectedOrganisationId: this.selectedOrganisation.id,
+            eventName: event.event_name
+          });
+          return;
+        }
+      } catch (error) {
+        console.error('[EventService] Error during event validation:', error);
+      }
+
+      this.selectedEvent = event;
+      this.setSelectedEventId?.(event.event_id);
+      this.persistEventSelection(event.event_id);
+      // Reset the user cleared flag when selecting an event
+      this.userClearedEventRef = false;
+    } else {
+      this.selectedEvent = null;
+      this.setSelectedEventId?.(null);
+      // Clear both sessionStorage and localStorage
+      sessionStorage.removeItem('pace-core-selected-event');
+      localStorage.removeItem('pace-core-selected-event');
+      // Reset the auto-selection flag when clearing the event
+      this.hasAutoSelectedRef = false;
+      // Mark that user explicitly cleared the event to prevent auto-selection
+      this.userClearedEventRef = true;
+    }
+    this.notify();
+  }
+
+  async refreshEvents(): Promise<void> {
+    this.isInitializedRef = false;
+    this.isFetchingRef = false;
+    // Don't reset the user cleared flag - respect user's choice
+    await this.fetchEvents();
+  }
+
+  async loadPersistedEvent(events: Event[]): Promise<boolean> {
+    try {
+      // Try sessionStorage first (tab-specific)
+      let persistedEventId = sessionStorage.getItem('pace-core-selected-event');
+      
+      // Fallback to localStorage if no sessionStorage value (for new tabs)
+      if (!persistedEventId) {
+        persistedEventId = localStorage.getItem('pace-core-selected-event');
+        // If we found a value in localStorage, also store it in sessionStorage for this tab
+        if (persistedEventId) {
+          sessionStorage.setItem('pace-core-selected-event', persistedEventId);
+        }
+      }
+      
+      if (persistedEventId && events.length > 0) {
+        const persistedEvent = events.find(event => event.event_id === persistedEventId);
+        if (persistedEvent) {
+          DebugLogger.log('EventService', 'Restoring persisted event:', persistedEvent.event_name);
+          this.selectedEvent = persistedEvent;
+          this.setSelectedEventId?.(persistedEventId);
+          return true;
+        } else {
+          DebugLogger.log('EventService', 'Persisted event not found in current events, clearing storage');
+          // Clear invalid persisted event
+          sessionStorage.removeItem('pace-core-selected-event');
+          localStorage.removeItem('pace-core-selected-event');
+        }
+      }
+    } catch (error) {
+      console.warn('[EventService] Failed to load persisted event:', error);
+    }
+    return false;
+  }
+
+  persistEventSelection(eventId: string): void {
+    try {
+      // Store in sessionStorage for tab-specific persistence
+      sessionStorage.setItem('pace-core-selected-event', eventId);
+      // Also store in localStorage as fallback for new tabs
+      localStorage.setItem('pace-core-selected-event', eventId);
+    } catch (error) {
+      console.warn('[EventService] Failed to persist event selection:', error);
+    }
+  }
+
+  clearEventSelection(): void {
+    try {
+      // Clear from both storage locations
+      sessionStorage.removeItem('pace-core-selected-event');
+      localStorage.removeItem('pace-core-selected-event');
+      // Clear the selected event
+      this.selectedEvent = null;
+      this.setSelectedEventId?.(null);
+    } catch (error) {
+      console.warn('[EventService] Failed to clear event selection:', error);
+    }
+  }
+
+  autoSelectNextEvent(events: Event[]): void {
+    const nextEvent = this.getNextEventByDate(events);
+    if (nextEvent) {
+      DebugLogger.log('EventService', 'Auto-selecting next event:', nextEvent.event_name);
+      this.selectedEvent = nextEvent;
+      this.setSelectedEventId?.(nextEvent.event_id);
+      this.persistEventSelection(nextEvent.event_id);
+    }
+  }
+
+  // Lifecycle methods
+  async initialize(): Promise<void> {
+    await super.initialize();
+    await this.fetchEvents();
+  }
+
+  cleanup(): void {
+    super.cleanup();
+  }
+
+  protected async doInitialize(): Promise<void> {
+    // Initial setup - fetch events on initialization
+    await this.fetchEvents();
+  }
+
+  protected doCleanup(): void {
+    // Cleanup any resources
+  }
+
+  private async fetchEvents(): Promise<void> {
+    if (!this.user || !this.session || !this.supabaseClient || !this.appName || !this.selectedOrganisation) {
+      DebugLogger.log('EventService', 'Missing required dependencies, skipping fetch');
+      this._isLoading = false;
+      this.notify();
+      return;
+    }
+
+    // Prevent multiple simultaneous fetches
+    if (this.isFetchingRef) {
+      DebugLogger.log('EventService', 'Already fetching events, skipping');
+      return;
+    }
+
+    DebugLogger.log('EventService', 'User and organisation found, fetching events for:', {
+      userId: this.user.id,
+      appName: this.appName,
+      organisationId: this.selectedOrganisation.id,
+      organisationName: this.selectedOrganisation.display_name
+    });
+
+    this.isFetchingRef = true;
+    let isMounted = true;
+
+    try {
+      // Call the RPC function following the established pattern
+      DebugLogger.log('EventService', 'Calling data_user_events_get RPC with:', {
+        user_id: this.user.id,
+        organisation_id: this.selectedOrganisation.id,
+        app_name: this.appName
+      });
+
+      const { data, error: rpcError } = await this.supabaseClient.rpc('data_user_events_get', {
+        p_user_id: this.user.id,
+        p_organisation_id: this.selectedOrganisation.id,
+        p_app_name: this.appName
+      });
+
+      DebugLogger.log('EventService', 'RPC response:', {
+        data,
+        error: rpcError,
+        dataLength: data?.length || 0,
+        organisationId: this.selectedOrganisation.id
+      });
+
+      if (rpcError) {
+        throw new Error(rpcError.message || 'Failed to fetch events');
+      }
+
+      if (isMounted) {
+        const eventsData = data || [];
+        console.log('[EventService] Loaded events:', eventsData.map((event: any) => ({
+          eventId: event.event_id,
+          eventName: event.event_name,
+          organisationId: event.organisation_id,
+          selectedOrganisationId: this.selectedOrganisation?.id
+        })));
+
+        // Transform the data to match our Event interface
+        const transformedEvents: Event[] = eventsData.map((event: any) => ({
+          id: event.event_id, // Use event_id as the primary id
+          event_id: event.event_id,
+          event_name: event.event_name,
+          event_date: event.event_date,
+          event_venue: event.event_venue,
+          event_participants: event.event_participants,
+          event_colours: event.event_colours,
+          event_logo: '', // No logo field in event table
+          organisation_id: event.organisation_id,
+          is_visible: event.is_visible,
+          // Legacy compatibility
+          name: event.event_name,
+          start_date: event.event_date
+        }));
+
+        this.events = transformedEvents;
+        this.error = null;
+
+        // Reset auto-selection ref for new events
+        this.hasAutoSelectedRef = false;
+
+        // Try to restore persisted event first
+        const persistedEventLoaded = await this.loadPersistedEvent(transformedEvents);
+        
+        // If no persisted event was loaded and user hasn't explicitly cleared an event, auto-select the next event
+        if (!persistedEventLoaded && !this.userClearedEventRef) {
+          const nextEvent = this.getNextEventByDate(transformedEvents);
+          if (nextEvent) {
+            DebugLogger.log('EventService', 'Auto-selecting next event after no persisted event found:', nextEvent.event_name);
+            this.hasAutoSelectedRef = true;
+            this.selectedEvent = nextEvent;
+            this.setSelectedEventId?.(nextEvent.event_id);
+            this.persistEventSelection(nextEvent.event_id);
+          }
+        }
+      }
+    } catch (err) {
+      console.error('[EventService] Error fetching events:', err);
+      const _error = err instanceof Error ? err : new Error('Unknown error occurred');
+      
+      if (isMounted) {
+        this.error = _error;
+        this.events = [];
+      }
+    } finally {
+      if (isMounted) {
+        this._isLoading = false;
+      }
+      this.isFetchingRef = false;
+      this.notify();
+    }
+  }
+
+  getNextEventByDate(events?: Event[]): Event | null {
+    const eventsToUse = events || this.events;
+    if (!eventsToUse || eventsToUse.length === 0) {
+      return null;
+    }
+
+    const now = new Date();
+    const futureEvents = eventsToUse.filter(event => {
+      if (!event.event_date) return false;
+      const eventDate = new Date(event.event_date);
+      return eventDate >= now;
+    });
+
+    if (futureEvents.length === 0) {
+      return null;
+    }
+
+    // Sort by date (ascending) to get the next event
+    const sortedFutureEvents = futureEvents.sort((a, b) => {
+      const dateA = new Date(a.event_date!);
+      const dateB = new Date(b.event_date!);
+      return dateA.getTime() - dateB.getTime();
+    });
+
+    return sortedFutureEvents[0];
+  }
+}