@flusys/nestjs-event-manager 4.1.1 → 5.0.1

package/cjs/services/event.service.js

@@ -17,6 +17,7 @@ const _config = require("../config");
 const _common = require("@nestjs/common");
 const _typeorm = require("typeorm");
 const _eventmanagerconfigservice = require("./event-manager-config.service");
+const _dtos = require("../dtos");
 const _entities = require("../entities");
 const _eventmanagerdatasourceprovider = require("./event-manager-datasource.provider");
 function _define_property(obj, key, value) {
@@ -56,6 +57,7 @@ let EventService = class EventService extends _classes.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({
@@ -69,19 +71,21 @@ let EventService = class EventService extends _classes.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 ?? _enums.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;
@@ -124,6 +128,8 @@ let EventService = class EventService extends _classes.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`, _entities.EventParticipant, 'ep', 'ep.event_id = event.id AND ep.deleted_at IS NULL');
         return result;
     }
     async afterInsertOperation(entities, user, _qr) {
@@ -133,20 +139,29 @@ let EventService = class EventService extends _classes.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: (0, _typeorm.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: _enums.RecurrenceType.NONE,
-            startDate: queryDto.startDate,
-            endDate: queryDto.endDate
+            endDate: queryDto.endDate,
+            none: _enums.RecurrenceType.NONE
         });
         this.applyEventCompanyFilter(query, user);
         if (queryDto.userId) {
@@ -165,75 +180,57 @@ let EventService = class EventService extends _classes.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: (0, _typeorm.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: (0, _typeorm.IsNull)()
+                id: dto.id
             }
         });
-        if (!event) {
+        if (!participant) {
             throw new _common.NotFoundException({
-                message: 'Event not found',
-                messageKey: _config.EVENT_MESSAGES.NOT_FOUND
+                message: 'Event participant not found',
+                messageKey: _config.EVENT_PARTICIPANT_MESSAGES.NOT_FOUND
             });
         }
-        const existingParticipants = await participantRepo.find({
-            where: {
-                eventId,
-                userId: (0, _typeorm.In)(userIds),
-                deletedAt: (0, _typeorm.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: (0, _typeorm.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 = [];
@@ -245,48 +242,44 @@ let EventService = class EventService extends _classes.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 === _enums.RecurrenceType.WEEKLY || recurrenceType === _enums.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 === _enums.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++;
             }
         }
@@ -331,41 +324,61 @@ let EventService = class EventService extends _classes.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 _enums.RecurrenceType.DAILY:
-                next.setDate(next.getDate() + 1);
+                d.setUTCDate(d.getUTCDate() + 1);
                 break;
             case _enums.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) {
@@ -373,15 +386,16 @@ let EventService = class EventService extends _classes.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,
@@ -391,6 +405,15 @@ let EventService = class EventService extends _classes.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,
@@ -398,7 +421,6 @@ let EventService = class EventService extends _classes.RequestScopedApiService {
             userId: p.userId,
             status: p.status,
             isOrganizer: p.isOrganizer,
-            metadata: p.metadata,
             createdAt: p.createdAt,
             updatedAt: p.updatedAt,
             deletedAt: p.deletedAt,
@@ -413,17 +435,16 @@ let EventService = class EventService extends _classes.RequestScopedApiService {
 };
 _ts_decorate([
     (0, _decorators.LogAction)({
-        action: 'event.addParticipants',
+        action: 'eventParticipant.updateStatus',
         module: 'event-manager'
     }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        String,
-        Array,
+        typeof _dtos.UpdateParticipantStatusDto === "undefined" ? Object : _dtos.UpdateParticipantStatusDto,
         Object
     ]),
     _ts_metadata("design:returntype", Promise)
-], EventService.prototype, "addParticipants", null);
+], EventService.prototype, "updateParticipantStatus", null);
 EventService = _ts_decorate([
     (0, _common.Injectable)({
         scope: _common.Scope.REQUEST

package/cjs/services/index.js

@@ -6,7 +6,6 @@ _export_star(require("./event-manager-config.service"), exports);
 _export_star(require("./event-manager-datasource.provider"), exports);
 _export_star(require("./event-manager-helper.service"), exports);
 _export_star(require("./event.service"), exports);
-_export_star(require("./event-participant.service"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/config/message-keys.d.ts

@@ -1,64 +1,8 @@
 export declare const EVENT_MESSAGES: {
-    readonly CREATE_SUCCESS: "event.create.success";
-    readonly CREATE_MANY_SUCCESS: "event.create.many.success";
-    readonly GET_SUCCESS: "event.get.success";
     readonly GET_ALL_SUCCESS: "event.get.all.success";
-    readonly UPDATE_SUCCESS: "event.update.success";
-    readonly UPDATE_MANY_SUCCESS: "event.update.many.success";
-    readonly DELETE_SUCCESS: "event.delete.success";
-    readonly RESTORE_SUCCESS: "event.restore.success";
     readonly NOT_FOUND: "event.not.found";
-    readonly PUBLISH_SUCCESS: "event.publish.success";
-    readonly UNPUBLISH_SUCCESS: "event.unpublish.success";
-    readonly CANCEL_SUCCESS: "event.cancel.success";
-    readonly UPCOMING_SUCCESS: "event.upcoming.success";
-    readonly MY_EVENTS_SUCCESS: "event.my.events.success";
 };
 export declare const EVENT_PARTICIPANT_MESSAGES: {
-    readonly CREATE_SUCCESS: "event.participant.create.success";
-    readonly CREATE_MANY_SUCCESS: "event.participant.create.many.success";
-    readonly GET_SUCCESS: "event.participant.get.success";
-    readonly GET_ALL_SUCCESS: "event.participant.get.all.success";
-    readonly UPDATE_SUCCESS: "event.participant.update.success";
-    readonly UPDATE_MANY_SUCCESS: "event.participant.update.many.success";
-    readonly DELETE_SUCCESS: "event.participant.delete.success";
-    readonly RESTORE_SUCCESS: "event.participant.restore.success";
     readonly NOT_FOUND: "event.participant.not.found";
-    readonly REGISTER_SUCCESS: "event.participant.register.success";
-    readonly UNREGISTER_SUCCESS: "event.participant.unregister.success";
-    readonly CHECKIN_SUCCESS: "event.participant.checkin.success";
     readonly STATUS_UPDATE_SUCCESS: "event.participant.status.update.success";
 };
-export declare const EVENT_MANAGER_MODULE_MESSAGES: {
-    readonly EVENT: {
-        readonly CREATE_SUCCESS: "event.create.success";
-        readonly CREATE_MANY_SUCCESS: "event.create.many.success";
-        readonly GET_SUCCESS: "event.get.success";
-        readonly GET_ALL_SUCCESS: "event.get.all.success";
-        readonly UPDATE_SUCCESS: "event.update.success";
-        readonly UPDATE_MANY_SUCCESS: "event.update.many.success";
-        readonly DELETE_SUCCESS: "event.delete.success";
-        readonly RESTORE_SUCCESS: "event.restore.success";
-        readonly NOT_FOUND: "event.not.found";
-        readonly PUBLISH_SUCCESS: "event.publish.success";
-        readonly UNPUBLISH_SUCCESS: "event.unpublish.success";
-        readonly CANCEL_SUCCESS: "event.cancel.success";
-        readonly UPCOMING_SUCCESS: "event.upcoming.success";
-        readonly MY_EVENTS_SUCCESS: "event.my.events.success";
-    };
-    readonly EVENT_PARTICIPANT: {
-        readonly CREATE_SUCCESS: "event.participant.create.success";
-        readonly CREATE_MANY_SUCCESS: "event.participant.create.many.success";
-        readonly GET_SUCCESS: "event.participant.get.success";
-        readonly GET_ALL_SUCCESS: "event.participant.get.all.success";
-        readonly UPDATE_SUCCESS: "event.participant.update.success";
-        readonly UPDATE_MANY_SUCCESS: "event.participant.update.many.success";
-        readonly DELETE_SUCCESS: "event.participant.delete.success";
-        readonly RESTORE_SUCCESS: "event.participant.restore.success";
-        readonly NOT_FOUND: "event.participant.not.found";
-        readonly REGISTER_SUCCESS: "event.participant.register.success";
-        readonly UNREGISTER_SUCCESS: "event.participant.unregister.success";
-        readonly CHECKIN_SUCCESS: "event.participant.checkin.success";
-        readonly STATUS_UPDATE_SUCCESS: "event.participant.status.update.success";
-    };
-};

package/controllers/event.controller.d.ts

@@ -1,6 +1,6 @@
 import { ListResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { BulkAddParticipantsDto, CalendarQueryDto, CalendarEventResponseDto, CreateEventDto, EventParticipantResponseDto, EventResponseDto, UpdateEventDto } from '../dtos';
+import { CalendarQueryDto, CalendarEventResponseDto, CreateEventDto, EventParticipantResponseDto, EventResponseDto, UpdateEventDto, UpdateParticipantStatusDto } from '../dtos';
 import { EventService } from '../services/event.service';
 declare const EventController_base: abstract new (service: EventService) => {
     readonly enabledEndpoints: import("@flusys/nestjs-shared/classes").ApiEndpoint[] | "all";
@@ -21,9 +21,6 @@ export declare class EventController extends EventController_base {
     protected eventService: EventService;
     constructor(eventService: EventService);
     getCalendarEvents(dto: CalendarQueryDto, user: ILoggedUserInfo): Promise<ListResponseDto<CalendarEventResponseDto>>;
-    getEventWithParticipants(body: {
-        id: string;
-    }, user: ILoggedUserInfo): Promise<SingleResponseDto<EventResponseDto>>;
-    addParticipants(dto: BulkAddParticipantsDto, user: ILoggedUserInfo): Promise<SingleResponseDto<EventParticipantResponseDto[]>>;
+    updateParticipantStatus(dto: UpdateParticipantStatusDto, user: ILoggedUserInfo): Promise<SingleResponseDto<EventParticipantResponseDto>>;
 }
 export {};

package/controllers/index.d.ts

@@ -1,2 +1 @@
 export * from './event.controller';
-export * from './event-participant.controller';

package/docs/index.d.ts

@@ -1,2 +1,2 @@
-export { EVENT_PERMISSIONS, EVENT_PARTICIPANT_PERMISSIONS } from '@flusys/nestjs-shared';
+export { EVENT_PERMISSIONS } from '@flusys/nestjs-shared';
 export { eventManagerSwaggerConfig } from './event-manager-swagger.config';

package/dtos/calendar-query.dto.d.ts

@@ -1,7 +1,7 @@
 import { EventParticipantResponseDto } from './event-participant.dto';
 export declare class CalendarQueryDto {
-    startDate: Date;
-    endDate: Date;
+    startDate: string;
+    endDate: string;
     includeParticipants?: boolean;
     userId?: string;
     activeOnly?: boolean;
@@ -10,12 +10,15 @@ export declare class CalendarEventResponseDto {
     id: string;
     title: string;
     description?: string | null;
-    meetingLink?: string | null;
-    startDateTime: Date;
-    endDateTime: Date;
+    eventDate: string;
+    startTime: string;
+    endTime: string;
     isAllDay: boolean;
     recurrenceType: string;
+    recurrenceEndDate?: string | null;
+    weekDays?: string[] | null;
     color: string;
+    meetingLink?: string | null;
     isActive: boolean;
     originalEventId?: string;
     isRecurrenceInstance?: boolean;

package/dtos/event-participant.dto.d.ts

@@ -4,7 +4,6 @@ export declare class CreateEventParticipantDto {
     userId: string;
     status?: ParticipantStatus;
     isOrganizer?: boolean;
-    metadata?: Record<string, unknown>;
 }
 declare const UpdateEventParticipantDto_base: import("@nestjs/common").Type<Partial<CreateEventParticipantDto>>;
 export declare class UpdateEventParticipantDto extends UpdateEventParticipantDto_base {
@@ -16,7 +15,6 @@ export declare class EventParticipantResponseDto {
     userId: string;
     status: string;
     isOrganizer: boolean;
-    metadata?: Record<string, unknown> | null;
     createdAt: Date;
     updatedAt: Date;
 }
@@ -24,8 +22,4 @@ export declare class UpdateParticipantStatusDto {
     id: string;
     status: ParticipantStatus;
 }
-export declare class BulkAddParticipantsDto {
-    eventId: string;
-    userIds: string[];
-}
 export {};

package/dtos/event.dto.d.ts

@@ -1,16 +1,18 @@
 import { RecurrenceType } from '@flusys/nestjs-shared/enums';
+import { EventParticipantResponseDto } from './event-participant.dto';
 export declare class CreateEventDto {
     title: string;
     description?: string;
-    meetingLink?: string;
-    startDateTime: Date;
-    endDateTime: Date;
+    eventDate: string;
+    startTime: string;
+    endTime: string;
     isAllDay?: boolean;
     recurrenceType?: RecurrenceType;
-    recurrenceEndDate?: Date;
+    recurrenceEndDate?: string | null;
+    weekDays?: string[] | null;
     color?: string;
     isActive?: boolean;
-    metadata?: Record<string, unknown>;
+    meetingLink?: string | null;
     participantIds?: string[];
 }
 declare const UpdateEventDto_base: import("@nestjs/common").Type<Partial<CreateEventDto>>;
@@ -21,17 +23,19 @@ export declare class EventResponseDto {
     id: string;
     title: string;
     description?: string | null;
-    meetingLink?: string | null;
-    startDateTime: Date;
-    endDateTime: Date;
+    eventDate: string;
+    startTime: string;
+    endTime: string;
     isAllDay: boolean;
     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;
     createdAt: Date;
     updatedAt: Date;
+    participants?: EventParticipantResponseDto[];
 }
 export {};

package/entities/event-participant.entity.d.ts

@@ -4,5 +4,4 @@ export declare class EventParticipant extends Identity {
     userId: string;
     status: string;
     isOrganizer: boolean;
-    metadata: Record<string, unknown> | null;
 }

package/entities/event.entity.d.ts

@@ -2,13 +2,14 @@ import { Identity } from '@flusys/nestjs-shared/entities';
 export declare class Event extends Identity {
     title: string;
     description: string | null;
-    meetingLink: string | null;
-    startDateTime: Date;
-    endDateTime: Date;
+    eventDate: string;
+    startTime: string;
+    endTime: string;
     isAllDay: boolean;
     recurrenceType: string;
-    recurrenceEndDate: Date | null;
+    recurrenceEndDate: string | null;
+    weekDays: string[] | null;
     color: string;
+    meetingLink: string | null;
     isActive: boolean;
-    metadata: Record<string, unknown> | null;
 }