Janus007/Calendar
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Major refactorering to get a hold on all these events

Browse source
This commit is contained in:
Janus Knudsen 2025-08-09 00:31:44 +02:00
parent 2a766cf685
commit 59b3c64c55
18 changed files with 1901 additions and 357 deletions
Download patch file Download diff file Expand all files Collapse all files

112
src/managers/EventManager.ts
View file

@ -1,6 +1,7 @@
import { EventBus } from '../core/EventBus';
import { IEventBus, CalendarEvent, ResourceCalendarData } from '../types/CalendarTypes';
import { EventTypes } from '../constants/EventTypes';
import { StateEvents } from '../types/CalendarState';
import { calendarConfig } from '../core/CalendarConfig';
/**
@ -15,33 +16,54 @@ export class EventManager {
console.log('EventManager: Constructor called');
this.eventBus = eventBus;
this.setupEventListeners();
console.log('EventManager: About to call loadMockData()');
this.loadMockData().then(() => {
console.log('EventManager: loadMockData() completed, syncing events');
// Data loaded, sync events after loading
this.syncEvents();
}).catch(error => {
console.error('EventManager: loadMockData() failed:', error);
});
console.log('EventManager: Waiting for CALENDAR_INITIALIZED before loading data');
}
private setupEventListeners(): void {
this.eventBus.on(EventTypes.CALENDAR_INITIALIZED, () => {
this.syncEvents();
// Listen for state-driven data loading request
this.eventBus.on(StateEvents.DATA_LOADING_STARTED, (e: Event) => {
const detail = (e as CustomEvent).detail;
console.log('EventManager: Received DATA_LOADING_STARTED, starting data load');
this.loadMockData().then(() => {
console.log('EventManager: loadMockData() completed, emitting DATA_LOADED');
// Emit state-driven data loaded event
this.eventBus.emit(StateEvents.DATA_LOADED, {
type: StateEvents.DATA_LOADED,
component: 'EventManager',
timestamp: Date.now(),
data: {
eventCount: this.events.length,
calendarMode: calendarConfig.getCalendarMode(),
period: detail.data?.period || { start: '', end: '' },
events: this.events // Include actual events for EventRenderer
},
metadata: {
phase: 'data-loading'
}
});
}).catch(error => {
console.error('EventManager: loadMockData() failed:', error);
this.eventBus.emit(StateEvents.DATA_FAILED, {
type: StateEvents.DATA_FAILED,
component: 'EventManager',
timestamp: Date.now(),
error,
metadata: {
phase: 'data-loading'
}
});
});
});
this.eventBus.on(EventTypes.DATE_CHANGED, () => {
this.syncEvents();
});
this.eventBus.on(EventTypes.VIEW_RENDERED, () => {
this.syncEvents();
});
// Legacy event listeners removed - data is now managed via state-driven events only
}
private async loadMockData(): Promise<void> {
try {
const calendarType = calendarConfig.getCalendarType();
const calendarType = calendarConfig.getCalendarMode();
let jsonFile: string;
console.log(`EventManager: Calendar type detected: '${calendarType}'`);
@ -59,43 +81,41 @@ export class EventManager {
throw new Error(`Failed to load mock events: ${response.status}`);
}
if (calendarType === 'resource') {
const resourceData: ResourceCalendarData = await response.json();
// Flatten events from all resources and add resource metadata
this.events = resourceData.resources.flatMap(resource =>
resource.events.map(event => ({
...event,
resourceName: resource.name,
resourceDisplayName: resource.displayName,
resourceEmployeeId: resource.employeeId
}))
);
console.log(`EventManager: Loaded ${this.events.length} events from ${resourceData.resources.length} resources`);
// Emit resource data for GridManager
this.eventBus.emit(EventTypes.RESOURCE_DATA_LOADED, {
resourceData: resourceData
});
} else {
this.events = await response.json();
console.log(`EventManager: Loaded ${this.events.length} date calendar events`);
}
const data = await response.json();
console.log(`EventManager: Loaded data for ${calendarType} calendar`);
console.log('EventManager: First event:', this.events[0]);
console.log('EventManager: Last event:', this.events[this.events.length - 1]);
// Remove legacy double emission - data is sent via StateEvents.DATA_LOADED only
// Process data for internal use
this.processCalendarData(calendarType, data);
} catch (error) {
console.error('EventManager: Failed to load mock events:', error);
this.events = []; // Fallback to empty array
}
}
private syncEvents(): void {
// Emit events for rendering
this.eventBus.emit(EventTypes.EVENTS_LOADED, {
events: this.events
});
private processCalendarData(calendarType: string, data: any): void {
if (calendarType === 'resource') {
const resourceData = data as ResourceCalendarData;
this.events = resourceData.resources.flatMap(resource =>
resource.events.map(event => ({
...event,
resourceName: resource.name,
resourceDisplayName: resource.displayName,
resourceEmployeeId: resource.employeeId
}))
);
console.log(`EventManager: Processed ${this.events.length} events from ${resourceData.resources.length} resources`);
} else {
this.events = data as CalendarEvent[];
console.log(`EventManager: Processed ${this.events.length} date events`);
}
}
console.log(`EventManager: Synced ${this.events.length} events`);
private syncEvents(): void {
// Events are now synced via StateEvents.DATA_LOADED during initialization
// This method maintained for internal state management only
console.log(`EventManager: Internal sync - ${this.events.length} events in memory`);
}
public getEvents(): CalendarEvent[] {