@flusys/nestjs-event-manager 3.0.1

package/fesm/services/event-manager-helper.service.js

@@ -0,0 +1,243 @@
+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 { Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { In, IsNull } from 'typeorm';
+import { HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { ParticipantStatus, RecurrenceType } from '@flusys/nestjs-shared';
+import { EventManagerConfigService } from './event-manager-config.service';
+import { EventManagerDataSourceProvider } from './event-manager-datasource.provider';
+import { Event, EventWithCompany, EventParticipant } from '../entities';
+export class EventManagerHelperService {
+    async getDataSource() {
+        if (!this.dataSource) {
+            this.dataSource = await this.dataSourceProvider.getDataSource();
+        }
+        return this.dataSource;
+    }
+    async getEventRepository() {
+        const ds = await this.getDataSource();
+        const EntityClass = this.configService.isCompanyFeatureEnabled() ? EventWithCompany : Event;
+        return ds.getRepository(EntityClass);
+    }
+    async getParticipantRepository() {
+        const ds = await this.getDataSource();
+        return ds.getRepository(EventParticipant);
+    }
+    async createEvent(options) {
+        const repo = await this.getEventRepository();
+        const entity = {
+            title: options.title,
+            description: options.description ?? null,
+            meetingLink: options.meetingLink ?? null,
+            startDateTime: options.startDateTime,
+            endDateTime: options.endDateTime,
+            isAllDay: options.isAllDay ?? false,
+            recurrenceType: options.recurrenceType ?? RecurrenceType.NONE,
+            recurrenceEndDate: options.recurrenceEndDate ?? null,
+            color: options.color ?? this.configService.getDefaultColor(),
+            isActive: true,
+            metadata: options.metadata ?? null
+        };
+        if (this.configService.isCompanyFeatureEnabled() && options.companyId) {
+            entity.companyId = options.companyId;
+        }
+        const saved = await repo.save(entity);
+        await this.addEventParticipants(saved.id, options.participantIds ?? [], options.organizerId);
+        await this.clearCache();
+        this.logger.debug(`Event created: ${saved.id} - ${options.title}`);
+        return this.toEventResult(saved);
+    }
+    async addParticipants(eventId, userIds, _companyId) {
+        const eventRepo = await this.getEventRepository();
+        const participantRepo = await this.getParticipantRepository();
+        const event = await eventRepo.findOne({
+            where: {
+                id: eventId,
+                deletedAt: IsNull()
+            }
+        });
+        if (!event) {
+            throw new NotFoundException('Event 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,
+                status: ParticipantStatus.PENDING,
+                isOrganizer: false
+            }));
+        if (newParticipants.length > 0) {
+            await participantRepo.save(newParticipants);
+            this.logger.debug(`Added ${newParticipants.length} participants to event ${eventId}`);
+        }
+    }
+    async removeParticipant(eventId, userId) {
+        const participantRepo = await this.getParticipantRepository();
+        const participant = await participantRepo.findOne({
+            where: {
+                eventId,
+                userId,
+                deletedAt: IsNull()
+            }
+        });
+        if (participant) {
+            await participantRepo.softRemove(participant);
+            this.logger.debug(`Removed participant ${userId} from event ${eventId}`);
+        }
+    }
+    async updateParticipantStatus(participantId, status) {
+        const participantRepo = await this.getParticipantRepository();
+        const participant = await participantRepo.findOne({
+            where: {
+                id: participantId,
+                deletedAt: IsNull()
+            }
+        });
+        if (!participant) {
+            throw new NotFoundException('Event participant not found');
+        }
+        participant.status = status;
+        await participantRepo.save(participant);
+        this.logger.debug(`Updated participant ${participantId} status to ${status}`);
+    }
+    async getEventsForUser(userId, startDate, endDate, companyId) {
+        const eventRepo = await this.getEventRepository();
+        const participantRepo = await this.getParticipantRepository();
+        const participantEvents = await participantRepo.createQueryBuilder('ep').select('ep.eventId').where('ep.userId = :userId', {
+            userId
+        }).andWhere('ep.deletedAt IS NULL').getRawMany();
+        const eventIds = participantEvents.map((p)=>p.ep_event_id);
+        if (eventIds.length === 0) {
+            return [];
+        }
+        const query = eventRepo.createQueryBuilder('event').where('event.id IN (:...eventIds)', {
+            eventIds
+        }).andWhere('event.deletedAt IS NULL').andWhere('event.isActive = :isActive', {
+            isActive: true
+        }).andWhere('event.startDateTime <= :endDate', {
+            endDate
+        }).andWhere('event.endDateTime >= :startDate', {
+            startDate
+        });
+        if (this.configService.isCompanyFeatureEnabled() && companyId) {
+            query.andWhere('event.companyId = :companyId', {
+                companyId
+            });
+        }
+        const events = await query.getMany();
+        return events.map((e)=>this.toEventResult(e));
+    }
+    async getEventById(eventId) {
+        const repo = await this.getEventRepository();
+        const event = await repo.findOne({
+            where: {
+                id: eventId,
+                deletedAt: IsNull()
+            }
+        });
+        return event ? this.toEventResult(event) : null;
+    }
+    async addEventParticipants(eventId, participantIds, organizerId) {
+        if (!organizerId && participantIds.length === 0) return;
+        const participantRepo = await this.getParticipantRepository();
+        const allUserIds = new Set([
+            ...organizerId ? [
+                organizerId
+            ] : [],
+            ...participantIds
+        ]);
+        const participants = Array.from(allUserIds).map((userId)=>({
+                eventId,
+                userId,
+                status: ParticipantStatus.PENDING,
+                isOrganizer: userId === organizerId
+            }));
+        await participantRepo.save(participants);
+    }
+    toEventResult(event) {
+        const eventExt = event;
+        return {
+            id: event.id,
+            title: event.title,
+            description: event.description,
+            meetingLink: event.meetingLink,
+            startDateTime: event.startDateTime,
+            endDateTime: event.endDateTime,
+            isAllDay: event.isAllDay,
+            recurrenceType: event.recurrenceType,
+            recurrenceEndDate: event.recurrenceEndDate,
+            color: event.color,
+            isActive: event.isActive,
+            metadata: event.metadata,
+            companyId: eventExt.companyId ?? null,
+            createdAt: event.createdAt,
+            updatedAt: event.updatedAt
+        };
+    }
+    async clearCache() {
+        await this.utilsService.clearCache(this.eventEntityName, this.cacheManager);
+    }
+    constructor(cacheManager, utilsService, configService, dataSourceProvider){
+        _define_property(this, "cacheManager", void 0);
+        _define_property(this, "utilsService", void 0);
+        _define_property(this, "configService", void 0);
+        _define_property(this, "dataSourceProvider", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "eventEntityName", void 0);
+        _define_property(this, "dataSource", void 0);
+        this.cacheManager = cacheManager;
+        this.utilsService = utilsService;
+        this.configService = configService;
+        this.dataSourceProvider = dataSourceProvider;
+        this.logger = new Logger(EventManagerHelperService.name);
+        this.eventEntityName = 'event';
+        this.dataSource = null;
+    }
+}
+EventManagerHelperService = _ts_decorate([
+    Injectable(),
+    _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
+    ])
+], EventManagerHelperService);

package/fesm/services/event-participant.service.js

@@ -0,0 +1,154 @@
+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 { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
+import { ParticipantStatus } from '@flusys/nestjs-shared/enums';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
+import { EventManagerConfigService } from './event-manager-config.service';
+import { EventParticipant } from '../entities';
+import { EventManagerDataSourceProvider } from './event-manager-datasource.provider';
+export class EventParticipantService extends RequestScopedApiService {
+    resolveEntity() {
+        // EventParticipant doesn't need company variant - company context is inherited through Event
+        return EventParticipant;
+    }
+    getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    // Override Methods
+    async convertSingleDtoToEntity(dto, _user) {
+        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('Event participant not found');
+            entity = existing;
+        }
+        // EventParticipant doesn't have companyId - company context comes from Event
+        return {
+            ...entity,
+            eventId: dto.eventId ?? entity.eventId,
+            userId: dto.userId ?? entity.userId,
+            status: dto.status ?? entity.status ?? ParticipantStatus.PENDING,
+            isOrganizer: dto.isOrganizer ?? entity.isOrganizer ?? false,
+            metadata: dto.metadata ?? entity.metadata
+        };
+    }
+    async getFilterQuery(query, filter, _user) {
+        for (const [key, value] of Object.entries(filter)){
+            if (key === 'eventId') {
+                query.andWhere(`${this.entityName}.eventId = :eventId`, {
+                    eventId: value
+                });
+            } else if (key === 'userId') {
+                query.andWhere(`${this.entityName}.userId = :userId`, {
+                    userId: value
+                });
+            } else if (key === 'status') {
+                query.andWhere(`${this.entityName}.status = :status`, {
+                    status: value
+                });
+            } else if (key === 'isOrganizer' && typeof value === 'boolean') {
+                query.andWhere(`${this.entityName}.isOrganizer = :isOrganizer`, {
+                    isOrganizer: value
+                });
+            } else {
+                query.andWhere(`${this.entityName}.${key} = :value`, {
+                    value
+                });
+            }
+        }
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    // Public Methods
+    // Note: EventParticipant doesn't have companyId - company filtering happens at Event level
+    async updateStatus(dto, _user) {
+        await this.ensureRepositoryInitialized();
+        const participant = await this.repository.findOne({
+            where: {
+                id: dto.id
+            }
+        });
+        if (!participant) {
+            throw new NotFoundException('Event participant not found');
+        }
+        participant.status = dto.status;
+        return this.repository.save(participant);
+    }
+    async getParticipantsByEvent(eventId, _user) {
+        await this.ensureRepositoryInitialized();
+        // Company filtering happens at Event level, not participant level
+        return this.repository.createQueryBuilder('event_participant').where('event_participant.eventId = :eventId', {
+            eventId
+        }).andWhere('event_participant.deletedAt IS NULL').getMany();
+    }
+    async getParticipantsByUser(userId, _user) {
+        await this.ensureRepositoryInitialized();
+        // Company filtering happens at Event level, not participant level
+        return this.repository.createQueryBuilder('event_participant').where('event_participant.userId = :userId', {
+            userId
+        }).andWhere('event_participant.deletedAt IS NULL').getMany();
+    }
+    async removeParticipant(eventId, userId, _user) {
+        await this.ensureRepositoryInitialized();
+        const participant = await this.repository.findOne({
+            where: {
+                eventId,
+                userId
+            }
+        });
+        if (participant) {
+            await this.repository.softRemove(participant);
+        }
+    }
+    constructor(cacheManager, utilsService, eventConfig, dataSourceProvider){
+        super('event_participant', null, cacheManager, utilsService, EventParticipantService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "eventConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.eventConfig = eventConfig, this.dataSourceProvider = dataSourceProvider;
+    }
+}
+EventParticipantService = _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
+    ])
+], EventParticipantService);