@flusys/nestjs-event-manager 7.1.0 → 8.0.0

package/fesm/services/event.service.js

@@ -1,471 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
-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 { Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
-import { In, IsNull } from 'typeorm';
-import { EVENT_MANAGER_EVENT_ACTIONS, EVENT_MANAGER_EVENT_ENTITIES, EVENT_MANAGER_EVENT_MODULE, EVENT_MESSAGES, EVENT_PARTICIPANT_MESSAGES } from '../config';
-import { UpdateParticipantStatusDto } from '../dtos';
-import { Event, EventParticipant, EventWithCompany } from '../entities';
-import { EventManagerConfigService } from './event-manager-config.service';
-import { EventManagerDataSourceProvider } from './event-manager-datasource.provider';
-export class EventService extends ApiService {
-    // Override methods
-    async convertSingleDtoToEntity(dto, user) {
-        await this.ensureDataSourceRepository();
-        let entity = {};
-        if ('id' in dto && dto.id && typeof dto.id === 'string') {
-            const existing = await this.repository.findOne({
-                where: {
-                    id: dto.id
-                }
-            });
-            if (!existing) throw new NotFoundException({
-                message: 'Event not found',
-                messageKey: EVENT_MESSAGES.NOT_FOUND
-            });
-            entity = existing;
-        }
-        const isAllDay = dto.isAllDay ?? entity.isAllDay ?? false;
-        const merged = {
-            ...entity,
-            title: dto.title ?? entity.title,
-            description: dto.description ?? entity.description,
-            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 ?? null,
-            weekDays: dto.weekDays ?? entity.weekDays ?? null,
-            color: dto.color ?? entity.color ?? this.eventConfig.getDefaultColor(),
-            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;
-        }
-        if ('participantIds' in dto) {
-            this.pendingParticipantsList.push(dto.participantIds ?? []);
-        }
-        return merged;
-    }
-    async getFilterQuery(query, filter, _user) {
-        for (const [key, value] of Object.entries(filter)){
-            if (key === 'isActive' && typeof value === 'boolean') {
-                query.andWhere(`${this.entityName}.isActive = :isActive`, {
-                    isActive: value
-                });
-            } else if (key === 'recurrenceType') {
-                query.andWhere(`${this.entityName}.recurrenceType = :recurrenceType`, {
-                    recurrenceType: value
-                });
-            } else if (key === 'participantUserId' && typeof value === 'string') {
-                const eventIds = await this.getParticipantEventIds(value);
-                if (eventIds.length > 0) {
-                    query.andWhere(`${this.entityName}.id IN (:...participantEventIds)`, {
-                        participantEventIds: eventIds
-                    });
-                } else {
-                    query.andWhere('1 = 0');
-                }
-            } else {
-                query.andWhere(`${this.entityName}.${key} = :value`, {
-                    value
-                });
-            }
-        }
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    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, _dto, user, _qr) {
-        for(let i = 0; i < entities.length; i++){
-            const participantIds = this.pendingParticipantsList[i] ?? [];
-            await this.addCreatorAndParticipants(entities[i].id, participantIds, user);
-        }
-        this.pendingParticipantsList = [];
-    }
-    async afterUpdateOperation(entities, _dto, 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.ensureDataSourceRepository();
-        const query = this.repository.createQueryBuilder('event').where('event.deletedAt IS NULL').andWhere('event.isActive = :isActive', {
-            isActive: queryDto.activeOnly !== false
-        }).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,
-            none: RecurrenceType.NONE
-        });
-        this.applyEventCompanyFilter(query, user);
-        if (queryDto.userId) {
-            const eventIds = await this.getParticipantEventIds(queryDto.userId);
-            if (eventIds.length > 0) {
-                query.andWhere('event.id IN (:...eventIds)', {
-                    eventIds
-                });
-            } else {
-                return [];
-            }
-        }
-        const events = await query.getMany();
-        if (queryDto.includeParticipants && events.length > 0) {
-            await this.loadParticipantsForEvents(events);
-        }
-        return this.expandRecurringEvents(events, queryDto.startDate, queryDto.endDate);
-    }
-    async updateParticipantStatus(dto, user) {
-        const participantRepo = await this.ensureParticipantRepositoryInitialized();
-        const participant = await participantRepo.findOne({
-            where: {
-                id: dto.id
-            }
-        });
-        if (!participant) {
-            throw new NotFoundException({
-                message: 'Event participant not found',
-                messageKey: EVENT_PARTICIPANT_MESSAGES.NOT_FOUND
-            });
-        }
-        participant.status = dto.status;
-        const saved = await participantRepo.save(participant);
-        await Promise.all([
-            this.clearCacheForAll(),
-            this.clearCacheForId([
-                {
-                    id: participant.eventId
-                }
-            ])
-        ]);
-        await this.publishDomainAction(EVENT_MANAGER_EVENT_ACTIONS.PARTICIPANT_STATUS_CHANGED, {
-            ids: [
-                participant.eventId
-            ],
-            metadata: {
-                participantId: saved.id,
-                participantUserId: saved.userId,
-                status: saved.status
-            },
-            user
-        });
-        return saved;
-    }
-    // Private business logic helpers
-    async addCreatorAndParticipants(eventId, participantIds, user) {
-        if (!user?.id) return;
-        const participantRepo = await this.ensureParticipantRepositoryInitialized();
-        const allUserIds = Array.from(new Set([
-            user.id,
-            ...participantIds
-        ]));
-        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(toSave);
-    }
-    expandRecurringEvents(events, rangeStart, rangeEnd) {
-        const result = [];
-        const maxOccurrences = this.eventConfig.getMaxRecurrenceOccurrences();
-        for (const event of events){
-            if (event.recurrenceType === RecurrenceType.NONE) {
-                result.push(this.toCalendarEvent(event));
-            } else {
-                result.push(...this.generateOccurrences(event, rangeStart, rangeEnd, maxOccurrences));
-            }
-        }
-        return result.sort((a, b)=>a.eventDate.localeCompare(b.eventDate));
-    }
-    generateOccurrences(event, rangeStart, rangeEnd, maxOccurrences) {
-        const occurrences = [];
-        const recurrenceEnd = event.recurrenceEndDate ?? null;
-        const recurrenceType = event.recurrenceType;
-        const weekDays = event.weekDays ?? [
-            this.getDayOfWeek(event.eventDate)
-        ];
-        let currentDate = event.eventDate;
-        let count = 0;
-        if (recurrenceType === RecurrenceType.WEEKLY || recurrenceType === RecurrenceType.BIWEEKLY) {
-            let weekStart = this.getWeekStart(event.eventDate);
-            while(count < maxOccurrences){
-                for (const dayOfWeek of weekDays){
-                    if (count >= maxOccurrences) break;
-                    currentDate = this.addDaysToDate(weekStart, this.weekdayNameToIndex(dayOfWeek));
-                    if (currentDate < event.eventDate) continue;
-                    if (this.shouldStopRecurrence(currentDate, recurrenceEnd, rangeEnd)) {
-                        count = maxOccurrences;
-                        break;
-                    }
-                    if (currentDate >= rangeStart && currentDate <= rangeEnd) {
-                        occurrences.push(this.toCalendarEventOnDate(event, currentDate, occurrences.length > 0));
-                    }
-                    count++;
-                }
-                const weeksToAdd = recurrenceType === RecurrenceType.BIWEEKLY ? 2 : 1;
-                weekStart = this.addDaysToDate(weekStart, 7 * weeksToAdd);
-            }
-        } else {
-            const originalDayOfMonth = parseInt(event.eventDate.split('-')[2], 10);
-            while(count < maxOccurrences){
-                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++;
-            }
-        }
-        return occurrences;
-    }
-    // Private utility helpers
-    async ensureParticipantRepositoryInitialized() {
-        if (!this.participantRepository) {
-            this.participantRepository = await this.dataSourceProvider.getRepository(EventParticipant);
-        }
-        return this.participantRepository;
-    }
-    async getParticipantEventIds(userId) {
-        const participantRepo = await this.ensureParticipantRepositoryInitialized();
-        const results = await participantRepo.createQueryBuilder('ep').select('ep.eventId').where('ep.userId = :userId', {
-            userId
-        }).andWhere('ep.deletedAt IS NULL').getRawMany();
-        return results.map((p)=>p.ep_event_id);
-    }
-    async loadParticipantsForEvents(events) {
-        const participantRepo = await this.ensureParticipantRepositoryInitialized();
-        const eventIds = events.map((e)=>e.id);
-        const participants = await participantRepo.find({
-            where: {
-                eventId: In(eventIds),
-                deletedAt: IsNull()
-            }
-        });
-        const participantsByEvent = new Map();
-        for (const p of participants){
-            const list = participantsByEvent.get(p.eventId) || [];
-            list.push(p);
-            participantsByEvent.set(p.eventId, list);
-        }
-        for (const event of events){
-            event.participants = participantsByEvent.get(event.id) || [];
-        }
-    }
-    applyEventCompanyFilter(query, user) {
-        applyCompanyFilter(query, {
-            isCompanyFeatureEnabled: this.eventConfig.isCompanyFeatureEnabled(),
-            entityAlias: 'event'
-        }, user);
-    }
-    shouldStopRecurrence(currentDate, recurrenceEnd, rangeEnd) {
-        return recurrenceEnd !== null && currentDate > recurrenceEnd || currentDate > rangeEnd;
-    }
-    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 d = new Date(`${current}T00:00:00Z`);
-        switch(recurrenceType){
-            case RecurrenceType.DAILY:
-                d.setUTCDate(d.getUTCDate() + 1);
-                break;
-            case RecurrenceType.MONTHLY:
-                {
-                    // Compute the target year/month from the *original* date before any mutation.
-                    // Mutating `d` first (e.g. via setUTCMonth) can overflow past short months
-                    // (Jan 31 -> Feb 31 normalizes to Mar 3), which would then compute
-                    // `lastDayOfMonth` for the wrong (already-overflowed) month and silently
-                    // skip target months that have fewer days than the original day-of-month.
-                    const targetDay = originalDayOfMonth ?? d.getUTCDate();
-                    const targetYear = d.getUTCFullYear();
-                    const targetMonth = d.getUTCMonth() + 1;
-                    const lastDayOfMonth = new Date(Date.UTC(targetYear, targetMonth + 1, 0)).getUTCDate();
-                    return new Date(Date.UTC(targetYear, targetMonth, Math.min(targetDay, lastDayOfMonth))).toISOString().slice(0, 10);
-                }
-            default:
-                break;
-        }
-        return d.toISOString().slice(0, 10);
-    }
-    // Private transformation helpers
-    toCalendarEvent(event) {
-        return {
-            id: event.id,
-            title: event.title,
-            description: event.description,
-            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,
-            createdAt: event.createdAt,
-            updatedAt: event.updatedAt,
-            deletedAt: event.deletedAt,
-            createdById: event.createdById,
-            updatedById: event.updatedById,
-            deletedById: event.deletedById,
-            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,
-            eventId: p.eventId,
-            userId: p.userId,
-            status: p.status,
-            isOrganizer: p.isOrganizer,
-            createdAt: p.createdAt,
-            updatedAt: p.updatedAt,
-            deletedAt: p.deletedAt,
-            createdById: p.createdById,
-            updatedById: p.updatedById,
-            deletedById: p.deletedById
-        };
-    }
-    constructor(cacheManager, utilsService, eventConfig, dataSourceProvider){
-        super(EVENT_MANAGER_EVENT_ENTITIES.EVENT, cacheManager, utilsService, EventService.name, true, EVENT_MANAGER_EVENT_MODULE, dataSourceProvider, eventConfig.isCompanyFeatureEnabled() ? EventWithCompany : Event), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "eventConfig", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "participantRepository", void 0), _define_property(this, "pendingParticipantsList", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.eventConfig = eventConfig, this.dataSourceProvider = dataSourceProvider, this.participantRepository = null, this.pendingParticipantsList = [];
-    }
-}
-_ts_decorate([
-    LogAction({
-        action: 'eventParticipant.updateStatus',
-        module: 'event-manager'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof UpdateParticipantStatusDto === "undefined" ? Object : UpdateParticipantStatusDto,
-        Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], EventService.prototype, "updateParticipantStatus", null);
-EventService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject('CACHE_INSTANCE')),
-    _ts_param(1, Inject(UtilsService)),
-    _ts_param(2, Inject(EventManagerConfigService)),
-    _ts_param(3, Inject(EventManagerDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof EventManagerConfigService === "undefined" ? Object : EventManagerConfigService,
-        typeof EventManagerDataSourceProvider === "undefined" ? Object : EventManagerDataSourceProvider
-    ])
-], EventService);