@flusys/nestjs-event-manager 4.1.0 → 5.0.0

package/fesm/services/event.service.js

@@ -30,10 +30,11 @@ import { LogAction } from '@flusys/nestjs-shared/decorators';
 import { RecurrenceType } from '@flusys/nestjs-shared/enums';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
-import { EVENT_MESSAGES } from '../config';
+import { EVENT_MESSAGES, EVENT_PARTICIPANT_MESSAGES } from '../config';
 import { Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
 import { In, IsNull } from 'typeorm';
 import { EventManagerConfigService } from './event-manager-config.service';
+import { UpdateParticipantStatusDto } from '../dtos';
 import { Event, EventWithCompany, EventParticipant } from '../entities';
 import { EventManagerDataSourceProvider } from './event-manager-datasource.provider';
 export class EventService extends RequestScopedApiService {
@@ -46,6 +47,7 @@ export class EventService extends RequestScopedApiService {
     }
     // Override methods
     async convertSingleDtoToEntity(dto, user) {
+        await this.ensureRepositoryInitialized();
         let entity = {};
         if ('id' in dto && dto.id && typeof dto.id === 'string') {
             const existing = await this.repository.findOne({
@@ -59,19 +61,21 @@ export class EventService extends RequestScopedApiService {
             });
             entity = existing;
         }
+        const isAllDay = dto.isAllDay ?? entity.isAllDay ?? false;
         const merged = {
             ...entity,
             title: dto.title ?? entity.title,
             description: dto.description ?? entity.description,
-            meetingLink: dto.meetingLink ?? entity.meetingLink,
-            startDateTime: dto.startDateTime ?? entity.startDateTime,
-            endDateTime: dto.endDateTime ?? entity.endDateTime,
-            isAllDay: dto.isAllDay ?? entity.isAllDay ?? false,
+            eventDate: dto.eventDate ?? entity.eventDate,
+            startTime: isAllDay ? '00:00' : dto.startTime ?? entity.startTime ?? '00:00',
+            endTime: isAllDay ? '23:59' : dto.endTime ?? entity.endTime ?? '23:59',
+            isAllDay,
             recurrenceType: dto.recurrenceType ?? entity.recurrenceType ?? RecurrenceType.NONE,
-            recurrenceEndDate: dto.recurrenceEndDate ?? entity.recurrenceEndDate,
+            recurrenceEndDate: dto.recurrenceEndDate ?? entity.recurrenceEndDate ?? null,
+            weekDays: dto.weekDays ?? entity.weekDays ?? null,
             color: dto.color ?? entity.color ?? this.eventConfig.getDefaultColor(),
-            isActive: dto.isActive ?? entity.isActive ?? true,
-            metadata: dto.metadata ?? entity.metadata
+            meetingLink: dto.meetingLink !== undefined ? dto.meetingLink ?? null : entity.meetingLink ?? null,
+            isActive: dto.isActive ?? entity.isActive ?? true
         };
         if (this.eventConfig.isCompanyFeatureEnabled()) {
             merged.companyId = user?.companyId ?? null;
@@ -114,6 +118,8 @@ export class EventService extends RequestScopedApiService {
     async getExtraManipulateQuery(query, filterDto, user) {
         const result = await super.getExtraManipulateQuery(query, filterDto, user);
         this.applyEventCompanyFilter(query, user);
+        await this.ensureParticipantRepositoryInitialized();
+        query.leftJoinAndMapMany(`${this.entityName}.participants`, EventParticipant, 'ep', 'ep.event_id = event.id AND ep.deleted_at IS NULL');
         return result;
     }
     async afterInsertOperation(entities, user, _qr) {
@@ -123,20 +129,29 @@ export class EventService extends RequestScopedApiService {
         }
         this.pendingParticipantsList = [];
     }
+    async afterUpdateOperation(entities, user, _qr) {
+        const participantRepo = await this.ensureParticipantRepositoryInitialized();
+        for(let i = 0; i < entities.length; i++){
+            const participantIds = this.pendingParticipantsList[i] ?? [];
+            await participantRepo.update({
+                eventId: entities[i].id,
+                deletedAt: IsNull()
+            }, {
+                deletedAt: new Date()
+            });
+            await this.addCreatorAndParticipants(entities[i].id, participantIds, user);
+        }
+        this.pendingParticipantsList = [];
+    }
     // Public API methods
     async getEventsForCalendarRange(queryDto, user) {
         await this.ensureRepositoryInitialized();
         const query = this.repository.createQueryBuilder('event').where('event.deletedAt IS NULL').andWhere('event.isActive = :isActive', {
             isActive: queryDto.activeOnly !== false
-        });
-        query.andWhere('(event.startDateTime <= :endDate AND event.endDateTime >= :startDate)', {
+        }).andWhere('((event.eventDate >= :startDate AND event.eventDate <= :endDate) OR (event.recurrenceType != :none AND event.eventDate <= :endDate AND (event.recurrenceEndDate IS NULL OR event.recurrenceEndDate >= :startDate)))', {
             startDate: queryDto.startDate,
-            endDate: queryDto.endDate
-        });
-        query.orWhere('event.deletedAt IS NULL AND event.recurrenceType != :none AND event.startDateTime <= :endDate AND (event.recurrenceEndDate IS NULL OR event.recurrenceEndDate >= :startDate)', {
-            none: RecurrenceType.NONE,
-            startDate: queryDto.startDate,
-            endDate: queryDto.endDate
+            endDate: queryDto.endDate,
+            none: RecurrenceType.NONE
         });
         this.applyEventCompanyFilter(query, user);
         if (queryDto.userId) {
@@ -155,75 +170,57 @@ export class EventService extends RequestScopedApiService {
         }
         return this.expandRecurringEvents(events, queryDto.startDate, queryDto.endDate);
     }
-    async getEventWithParticipants(id, user) {
-        await this.ensureRepositoryInitialized();
-        const query = this.repository.createQueryBuilder('event').where('event.id = :id', {
-            id
-        }).andWhere('event.deletedAt IS NULL');
-        this.applyEventCompanyFilter(query, user);
-        const event = await query.getOne();
-        if (event) {
-            const participantRepo = await this.ensureParticipantRepositoryInitialized();
-            event.participants = await participantRepo.find({
-                where: {
-                    eventId: id,
-                    deletedAt: IsNull()
-                }
-            });
-        }
-        return event;
-    }
-    async addParticipants(eventId, userIds, _user) {
-        await this.ensureRepositoryInitialized();
+    async updateParticipantStatus(dto, _user) {
         const participantRepo = await this.ensureParticipantRepositoryInitialized();
-        const event = await this.repository.findOne({
+        const participant = await participantRepo.findOne({
             where: {
-                id: eventId,
-                deletedAt: IsNull()
+                id: dto.id
             }
         });
-        if (!event) {
+        if (!participant) {
             throw new NotFoundException({
-                message: 'Event not found',
-                messageKey: EVENT_MESSAGES.NOT_FOUND
+                message: 'Event participant not found',
+                messageKey: EVENT_PARTICIPANT_MESSAGES.NOT_FOUND
             });
         }
-        const existingParticipants = await participantRepo.find({
-            where: {
-                eventId,
-                userId: In(userIds),
-                deletedAt: IsNull()
-            }
-        });
-        const existingUserIds = new Set(existingParticipants.map((p)=>p.userId));
-        const newParticipants = userIds.filter((userId)=>!existingUserIds.has(userId)).map((userId)=>({
-                eventId,
-                userId,
-                isOrganizer: false
-            }));
-        if (newParticipants.length === 0) {
-            return existingParticipants;
-        }
-        const created = await participantRepo.save(newParticipants);
-        return [
-            ...existingParticipants,
-            ...created
-        ];
+        participant.status = dto.status;
+        return participantRepo.save(participant);
     }
     // Private business logic helpers
     async addCreatorAndParticipants(eventId, participantIds, user) {
         if (!user?.id) return;
         const participantRepo = await this.ensureParticipantRepositoryInitialized();
-        const allUserIds = new Set([
+        const allUserIds = Array.from(new Set([
             user.id,
             ...participantIds
-        ]);
-        const participants = Array.from(allUserIds).map((userId)=>({
+        ]));
+        const existing = await participantRepo.find({
+            where: {
+                eventId,
+                userId: In(allUserIds)
+            },
+            withDeleted: true
+        });
+        const existingByUserId = new Map(existing.map((p)=>[
+                p.userId,
+                p
+            ]));
+        const toSave = allUserIds.map((userId)=>{
+            const existingRecord = existingByUserId.get(userId);
+            if (existingRecord) {
+                return {
+                    ...existingRecord,
+                    deletedAt: null,
+                    isOrganizer: userId === user.id
+                };
+            }
+            return {
                 eventId,
                 userId,
                 isOrganizer: userId === user.id
-            }));
-        await participantRepo.save(participants);
+            };
+        });
+        await participantRepo.save(toSave);
     }
     expandRecurringEvents(events, rangeStart, rangeEnd) {
         const result = [];
@@ -235,48 +232,44 @@ export class EventService extends RequestScopedApiService {
                 result.push(...this.generateOccurrences(event, rangeStart, rangeEnd, maxOccurrences));
             }
         }
-        return result.sort((a, b)=>new Date(a.startDateTime).getTime() - new Date(b.startDateTime).getTime());
+        return result.sort((a, b)=>a.eventDate.localeCompare(b.eventDate));
     }
     generateOccurrences(event, rangeStart, rangeEnd, maxOccurrences) {
         const occurrences = [];
-        const eventDuration = new Date(event.endDateTime).getTime() - new Date(event.startDateTime).getTime();
-        const recurrenceEnd = event.recurrenceEndDate ? new Date(event.recurrenceEndDate) : null;
+        const recurrenceEnd = event.recurrenceEndDate ?? null;
         const recurrenceType = event.recurrenceType;
-        const recurrenceDays = event.metadata?.recurrenceDays || [
-            new Date(event.startDateTime).getDay()
+        const weekDays = event.weekDays ?? [
+            this.getDayOfWeek(event.eventDate)
         ];
-        let currentStart = new Date(event.startDateTime);
+        let currentDate = event.eventDate;
         let count = 0;
         if (recurrenceType === RecurrenceType.WEEKLY || recurrenceType === RecurrenceType.BIWEEKLY) {
-            let weekStart = new Date(event.startDateTime);
-            weekStart.setDate(weekStart.getDate() - weekStart.getDay());
+            let weekStart = this.getWeekStart(event.eventDate);
             while(count < maxOccurrences){
-                for (const dayOfWeek of recurrenceDays){
+                for (const dayOfWeek of weekDays){
                     if (count >= maxOccurrences) break;
-                    currentStart = new Date(weekStart);
-                    currentStart.setDate(currentStart.getDate() + dayOfWeek);
-                    currentStart.setHours(new Date(event.startDateTime).getHours());
-                    currentStart.setMinutes(new Date(event.startDateTime).getMinutes());
-                    if (currentStart < new Date(event.startDateTime)) continue;
-                    const shouldBreak = this.shouldStopRecurrence(currentStart, recurrenceEnd, rangeEnd);
-                    if (shouldBreak) {
+                    currentDate = this.addDaysToDate(weekStart, this.weekdayNameToIndex(dayOfWeek));
+                    if (currentDate < event.eventDate) continue;
+                    if (this.shouldStopRecurrence(currentDate, recurrenceEnd, rangeEnd)) {
                         count = maxOccurrences;
                         break;
                     }
-                    const occurrence = this.tryCreateOccurrence(event, currentStart, eventDuration, rangeStart, rangeEnd, occurrences.length > 0);
-                    if (occurrence) occurrences.push(occurrence);
+                    if (currentDate >= rangeStart && currentDate <= rangeEnd) {
+                        occurrences.push(this.toCalendarEventOnDate(event, currentDate, occurrences.length > 0));
+                    }
                     count++;
                 }
                 const weeksToAdd = recurrenceType === RecurrenceType.BIWEEKLY ? 2 : 1;
-                weekStart.setDate(weekStart.getDate() + 7 * weeksToAdd);
+                weekStart = this.addDaysToDate(weekStart, 7 * weeksToAdd);
             }
         } else {
-            const originalDayOfMonth = new Date(event.startDateTime).getDate();
+            const originalDayOfMonth = parseInt(event.eventDate.split('-')[2], 10);
             while(count < maxOccurrences){
-                if (this.shouldStopRecurrence(currentStart, recurrenceEnd, rangeEnd)) break;
-                const occurrence = this.tryCreateOccurrence(event, currentStart, eventDuration, rangeStart, rangeEnd, count > 0);
-                if (occurrence) occurrences.push(occurrence);
-                currentStart = this.getNextOccurrenceDate(currentStart, recurrenceType, originalDayOfMonth);
+                if (this.shouldStopRecurrence(currentDate, recurrenceEnd, rangeEnd)) break;
+                if (currentDate >= rangeStart && currentDate <= rangeEnd) {
+                    occurrences.push(this.toCalendarEventOnDate(event, currentDate, count > 0));
+                }
+                currentDate = this.getNextOccurrenceDate(currentDate, recurrenceType, originalDayOfMonth);
                 count++;
             }
         }
@@ -321,41 +314,61 @@ export class EventService extends RequestScopedApiService {
             entityAlias: 'event'
         }, user);
     }
-    shouldStopRecurrence(currentStart, recurrenceEnd, rangeEnd) {
-        return recurrenceEnd && currentStart > recurrenceEnd || currentStart > rangeEnd;
+    shouldStopRecurrence(currentDate, recurrenceEnd, rangeEnd) {
+        return recurrenceEnd !== null && currentDate > recurrenceEnd || currentDate > rangeEnd;
     }
-    tryCreateOccurrence(event, currentStart, eventDuration, rangeStart, rangeEnd, isRecurrenceInstance) {
-        const currentEnd = new Date(currentStart.getTime() + eventDuration);
-        if (currentEnd >= rangeStart && currentStart <= rangeEnd) {
-            return {
-                ...this.toCalendarEvent(event),
-                id: `${event.id}_${currentStart.toISOString()}`,
-                originalEventId: event.id,
-                isRecurrenceInstance,
-                startDateTime: new Date(currentStart),
-                endDateTime: currentEnd
-            };
-        }
-        return null;
+    getDayOfWeek(dateStr) {
+        const days = [
+            'SUN',
+            'MON',
+            'TUE',
+            'WED',
+            'THU',
+            'FRI',
+            'SAT'
+        ];
+        return days[new Date(`${dateStr}T00:00:00Z`).getUTCDay()];
+    }
+    weekdayNameToIndex(day) {
+        const map = {
+            SUN: 0,
+            MON: 1,
+            TUE: 2,
+            WED: 3,
+            THU: 4,
+            FRI: 5,
+            SAT: 6
+        };
+        return map[day.toUpperCase()] ?? 0;
+    }
+    getWeekStart(dateStr) {
+        const d = new Date(`${dateStr}T00:00:00Z`);
+        d.setUTCDate(d.getUTCDate() - d.getUTCDay());
+        return d.toISOString().slice(0, 10);
+    }
+    addDaysToDate(dateStr, days) {
+        const d = new Date(`${dateStr}T00:00:00Z`);
+        d.setUTCDate(d.getUTCDate() + days);
+        return d.toISOString().slice(0, 10);
     }
     getNextOccurrenceDate(current, recurrenceType, originalDayOfMonth) {
-        const next = new Date(current);
+        const d = new Date(`${current}T00:00:00Z`);
         switch(recurrenceType){
             case RecurrenceType.DAILY:
-                next.setDate(next.getDate() + 1);
+                d.setUTCDate(d.getUTCDate() + 1);
                 break;
             case RecurrenceType.MONTHLY:
                 {
-                    const targetDay = originalDayOfMonth ?? current.getDate();
-                    next.setMonth(next.getMonth() + 1);
-                    const lastDayOfMonth = new Date(next.getFullYear(), next.getMonth() + 1, 0).getDate();
-                    next.setDate(Math.min(targetDay, lastDayOfMonth));
+                    const targetDay = originalDayOfMonth ?? d.getUTCDate();
+                    d.setUTCMonth(d.getUTCMonth() + 1);
+                    const lastDayOfMonth = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 0)).getUTCDate();
+                    d.setUTCDate(Math.min(targetDay, lastDayOfMonth));
                     break;
                 }
             default:
                 break;
         }
-        return next;
+        return d.toISOString().slice(0, 10);
     }
     // Private transformation helpers
     toCalendarEvent(event) {
@@ -363,15 +376,16 @@ export class EventService extends RequestScopedApiService {
             id: event.id,
             title: event.title,
             description: event.description,
-            meetingLink: event.meetingLink,
-            startDateTime: event.startDateTime,
-            endDateTime: event.endDateTime,
+            eventDate: event.eventDate,
+            startTime: event.startTime,
+            endTime: event.endTime,
             isAllDay: event.isAllDay,
             recurrenceType: event.recurrenceType,
             recurrenceEndDate: event.recurrenceEndDate,
+            weekDays: event.weekDays,
             color: event.color,
+            meetingLink: event.meetingLink ?? null,
             isActive: event.isActive,
-            metadata: event.metadata,
             createdAt: event.createdAt,
             updatedAt: event.updatedAt,
             deletedAt: event.deletedAt,
@@ -381,6 +395,15 @@ export class EventService extends RequestScopedApiService {
             participants: event.participants?.map((p)=>this.toParticipantInfo(p))
         };
     }
+    toCalendarEventOnDate(event, occurrenceDate, isRecurrenceInstance) {
+        return {
+            ...this.toCalendarEvent(event),
+            id: `${event.id}_${occurrenceDate}`,
+            originalEventId: event.id,
+            isRecurrenceInstance,
+            eventDate: occurrenceDate
+        };
+    }
     toParticipantInfo(p) {
         return {
             id: p.id,
@@ -388,7 +411,6 @@ export class EventService extends RequestScopedApiService {
             userId: p.userId,
             status: p.status,
             isOrganizer: p.isOrganizer,
-            metadata: p.metadata,
             createdAt: p.createdAt,
             updatedAt: p.updatedAt,
             deletedAt: p.deletedAt,
@@ -403,17 +425,16 @@ export class EventService extends RequestScopedApiService {
 }
 _ts_decorate([
     LogAction({
-        action: 'event.addParticipants',
+        action: 'eventParticipant.updateStatus',
         module: 'event-manager'
     }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        String,
-        Array,
+        typeof UpdateParticipantStatusDto === "undefined" ? Object : UpdateParticipantStatusDto,
         Object
     ]),
     _ts_metadata("design:returntype", Promise)
-], EventService.prototype, "addParticipants", null);
+], EventService.prototype, "updateParticipantStatus", null);
 EventService = _ts_decorate([
     Injectable({
         scope: Scope.REQUEST

package/fesm/services/index.js

@@ -2,4 +2,3 @@ export * from './event-manager-config.service';
 export * from './event-manager-datasource.provider';
 export * from './event-manager-helper.service';
 export * from './event.service';
-export * from './event-participant.service';

package/interfaces/event.interface.d.ts

@@ -3,15 +3,16 @@ import { IIdentity } from '@flusys/nestjs-shared/interfaces';
 export interface IEvent extends IIdentity {
     title: string;
     description: string | null;
-    meetingLink: string | null;
-    startDateTime: Date;
-    endDateTime: Date;
+    eventDate: string;
+    startTime: string;
+    endTime: string;
     isAllDay: boolean;
     recurrenceType: RecurrenceType | string;
-    recurrenceEndDate: Date | null;
+    recurrenceEndDate: string | null;
+    weekDays: string[] | null;
     color: string;
+    meetingLink: string | null;
     isActive: boolean;
-    metadata: Record<string, unknown> | null;
     companyId?: string | null;
 }
 export interface IEventParticipant extends IIdentity {
@@ -19,7 +20,6 @@ export interface IEventParticipant extends IIdentity {
     userId: string;
     status: ParticipantStatus | string;
     isOrganizer: boolean;
-    metadata: Record<string, unknown> | null;
 }
 export interface ICalendarEvent extends IEvent {
     originalEventId?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-event-manager",
-  "version": "4.1.0",
+  "version": "5.0.0",
   "description": "Event manager module with calendar support and recurrence",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -84,7 +84,7 @@
     "express": "^4.18.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "4.1.0",
-    "@flusys/nestjs-shared": "4.1.0"
+    "@flusys/nestjs-core": "5.0.0",
+    "@flusys/nestjs-shared": "5.0.0"
   }
 }

package/services/event-manager-helper.service.d.ts

@@ -15,10 +15,8 @@ export declare class EventManagerHelperService {
     private getEventRepository;
     private getParticipantRepository;
     createEvent(options: CreateEventOptions): Promise<EventResult>;
-    addParticipants(eventId: string, userIds: string[], _companyId?: string): Promise<void>;
-    removeParticipant(eventId: string, userId: string): Promise<void>;
     updateParticipantStatus(participantId: string, status: ParticipantStatus): Promise<void>;
-    getEventsForUser(userId: string, startDate: Date, endDate: Date, companyId?: string): Promise<EventResult[]>;
+    getEventsForUser(userId: string, startDate: string, endDate: string, companyId?: string): Promise<EventResult[]>;
     getEventById(eventId: string): Promise<EventResult | null>;
     private addEventParticipants;
     private toEventResult;

package/services/event.service.d.ts

@@ -3,13 +3,10 @@ import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { EntityTarget, QueryRunner, Repository, SelectQueryBuilder } from 'typeorm';
 import { EventManagerConfigService } from './event-manager-config.service';
-import { CalendarQueryDto, CreateEventDto, UpdateEventDto } from '../dtos';
+import { CalendarQueryDto, CreateEventDto, UpdateEventDto, UpdateParticipantStatusDto } from '../dtos';
 import { EventBase, EventParticipant } from '../entities';
 import { ICalendarEvent, IEvent } from '../interfaces';
 import { EventManagerDataSourceProvider } from './event-manager-datasource.provider';
-type EventWithParticipants = Omit<EventBase, 'participants'> & {
-    participants?: EventParticipant[];
-};
 export declare class EventService extends RequestScopedApiService<CreateEventDto, UpdateEventDto, IEvent, EventBase, Repository<EventBase>> {
     protected cacheManager: HybridCache;
     protected utilsService: UtilsService;
@@ -30,9 +27,9 @@ export declare class EventService extends RequestScopedApiService<CreateEventDto
         isRaw: boolean;
     }>;
     protected afterInsertOperation(entities: EventBase[], user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
+    protected afterUpdateOperation(entities: EventBase[], user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
     getEventsForCalendarRange(queryDto: CalendarQueryDto, user: ILoggedUserInfo | null): Promise<ICalendarEvent[]>;
-    getEventWithParticipants(id: string, user: ILoggedUserInfo | null): Promise<EventWithParticipants | null>;
-    addParticipants(eventId: string, userIds: string[], _user: ILoggedUserInfo | null): Promise<EventParticipant[]>;
+    updateParticipantStatus(dto: UpdateParticipantStatusDto, _user: ILoggedUserInfo | null): Promise<EventParticipant>;
     private addCreatorAndParticipants;
     private expandRecurringEvents;
     private generateOccurrences;
@@ -41,9 +38,12 @@ export declare class EventService extends RequestScopedApiService<CreateEventDto
     private loadParticipantsForEvents;
     private applyEventCompanyFilter;
     private shouldStopRecurrence;
-    private tryCreateOccurrence;
+    private getDayOfWeek;
+    private weekdayNameToIndex;
+    private getWeekStart;
+    private addDaysToDate;
     private getNextOccurrenceDate;
     private toCalendarEvent;
+    private toCalendarEventOnDate;
     private toParticipantInfo;
 }
-export {};

package/services/index.d.ts

@@ -2,4 +2,3 @@ export * from './event-manager-config.service';
 export * from './event-manager-datasource.provider';
 export * from './event-manager-helper.service';
 export * from './event.service';
-export * from './event-participant.service';