@flusys/nestjs-event-manager 3.0.1

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventParticipantService", {
+    enumerable: true,
+    get: function() {
+        return EventParticipantService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _enums = require("@flusys/nestjs-shared/enums");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _eventmanagerconfigservice = require("./event-manager-config.service");
+const _entities = require("../entities");
+const _eventmanagerdatasourceprovider = require("./event-manager-datasource.provider");
+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);
+    };
+}
+let EventParticipantService = class EventParticipantService extends _classes.RequestScopedApiService {
+    resolveEntity() {
+        // EventParticipant doesn't need company variant - company context is inherited through Event
+        return _entities.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 _common.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 ?? _enums.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 _common.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([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_eventmanagerconfigservice.EventManagerConfigService)),
+    _ts_param(3, (0, _common.Inject)(_eventmanagerdatasourceprovider.EventManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _eventmanagerconfigservice.EventManagerConfigService === "undefined" ? Object : _eventmanagerconfigservice.EventManagerConfigService,
+        typeof _eventmanagerdatasourceprovider.EventManagerDataSourceProvider === "undefined" ? Object : _eventmanagerdatasourceprovider.EventManagerDataSourceProvider
+    ])
+], EventParticipantService);

package/cjs/services/event.service.js

@@ -0,0 +1,421 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "EventService", {
+    enumerable: true,
+    get: function() {
+        return EventService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _enums = require("@flusys/nestjs-shared/enums");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _utils = require("@flusys/nestjs-shared/utils");
+const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
+const _eventmanagerconfigservice = require("./event-manager-config.service");
+const _entities = require("../entities");
+const _eventmanagerdatasourceprovider = require("./event-manager-datasource.provider");
+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);
+    };
+}
+let EventService = class EventService extends _classes.RequestScopedApiService {
+    // Abstract implementations
+    resolveEntity() {
+        return this.eventConfig.isCompanyFeatureEnabled() ? _entities.EventWithCompany : _entities.Event;
+    }
+    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 _common.NotFoundException('Event not found');
+            entity = existing;
+        }
+        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,
+            recurrenceType: dto.recurrenceType ?? entity.recurrenceType ?? _enums.RecurrenceType.NONE,
+            recurrenceEndDate: dto.recurrenceEndDate ?? entity.recurrenceEndDate,
+            color: dto.color ?? entity.color ?? this.eventConfig.getDefaultColor(),
+            isActive: dto.isActive ?? entity.isActive ?? true,
+            metadata: dto.metadata ?? entity.metadata
+        };
+        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' && value) {
+                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);
+        return result;
+    }
+    async afterInsertOperation(entities, 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 = [];
+    }
+    // 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)', {
+            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
+        });
+        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 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();
+        const participantRepo = await this.ensureParticipantRepositoryInitialized();
+        const event = await this.repository.findOne({
+            where: {
+                id: eventId,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (!event) {
+            throw new _common.NotFoundException('Event 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
+        ];
+    }
+    // Private business logic helpers
+    async addCreatorAndParticipants(eventId, participantIds, user) {
+        if (!user?.id) return;
+        const participantRepo = await this.ensureParticipantRepositoryInitialized();
+        const allUserIds = new Set([
+            user.id,
+            ...participantIds
+        ]);
+        const participants = Array.from(allUserIds).map((userId)=>({
+                eventId,
+                userId,
+                isOrganizer: userId === user.id
+            }));
+        await participantRepo.save(participants);
+    }
+    expandRecurringEvents(events, rangeStart, rangeEnd) {
+        const result = [];
+        const maxOccurrences = this.eventConfig.getMaxRecurrenceOccurrences();
+        for (const event of events){
+            if (event.recurrenceType === _enums.RecurrenceType.NONE) {
+                result.push(this.toCalendarEvent(event));
+            } else {
+                result.push(...this.generateOccurrences(event, rangeStart, rangeEnd, maxOccurrences));
+            }
+        }
+        return result.sort((a, b)=>new Date(a.startDateTime).getTime() - new Date(b.startDateTime).getTime());
+    }
+    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 recurrenceType = event.recurrenceType;
+        const recurrenceDays = event.metadata?.recurrenceDays || [
+            new Date(event.startDateTime).getDay()
+        ];
+        let currentStart = new Date(event.startDateTime);
+        let count = 0;
+        if (recurrenceType === _enums.RecurrenceType.WEEKLY || recurrenceType === _enums.RecurrenceType.BIWEEKLY) {
+            let weekStart = new Date(event.startDateTime);
+            weekStart.setDate(weekStart.getDate() - weekStart.getDay());
+            while(count < maxOccurrences){
+                for (const dayOfWeek of recurrenceDays){
+                    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) {
+                        count = maxOccurrences;
+                        break;
+                    }
+                    const occurrence = this.tryCreateOccurrence(event, currentStart, eventDuration, rangeStart, rangeEnd, occurrences.length > 0);
+                    if (occurrence) occurrences.push(occurrence);
+                    count++;
+                }
+                const weeksToAdd = recurrenceType === _enums.RecurrenceType.BIWEEKLY ? 2 : 1;
+                weekStart.setDate(weekStart.getDate() + 7 * weeksToAdd);
+            }
+        } else {
+            const originalDayOfMonth = new Date(event.startDateTime).getDate();
+            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);
+                count++;
+            }
+        }
+        return occurrences;
+    }
+    // Private utility helpers
+    async ensureParticipantRepositoryInitialized() {
+        if (!this.participantRepository) {
+            this.participantRepository = await this.dataSourceProvider.getRepository(_entities.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: (0, _typeorm.In)(eventIds),
+                deletedAt: (0, _typeorm.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) {
+        (0, _utils.applyCompanyFilter)(query, {
+            isCompanyFeatureEnabled: this.eventConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'event'
+        }, user);
+    }
+    shouldStopRecurrence(currentStart, recurrenceEnd, rangeEnd) {
+        return recurrenceEnd && currentStart > recurrenceEnd || currentStart > 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;
+    }
+    getNextOccurrenceDate(current, recurrenceType, originalDayOfMonth) {
+        const next = new Date(current);
+        switch(recurrenceType){
+            case _enums.RecurrenceType.DAILY:
+                next.setDate(next.getDate() + 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));
+                    break;
+                }
+            default:
+                break;
+        }
+        return next;
+    }
+    // Private transformation helpers
+    toCalendarEvent(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,
+            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))
+        };
+    }
+    toParticipantInfo(p) {
+        return {
+            id: p.id,
+            eventId: p.eventId,
+            userId: p.userId,
+            status: p.status,
+            isOrganizer: p.isOrganizer,
+            metadata: p.metadata,
+            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', null, cacheManager, utilsService, EventService.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), _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 = [];
+    }
+};
+EventService = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_eventmanagerconfigservice.EventManagerConfigService)),
+    _ts_param(3, (0, _common.Inject)(_eventmanagerdatasourceprovider.EventManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _eventmanagerconfigservice.EventManagerConfigService === "undefined" ? Object : _eventmanagerconfigservice.EventManagerConfigService,
+        typeof _eventmanagerdatasourceprovider.EventManagerDataSourceProvider === "undefined" ? Object : _eventmanagerdatasourceprovider.EventManagerDataSourceProvider
+    ])
+], EventService);

package/cjs/services/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_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)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/config/event-manager.constants.d.ts

@@ -0,0 +1 @@
+export declare const EVENT_MANAGER_MODULE_OPTIONS = "EVENT_MANAGER_MODULE_OPTIONS";

package/config/index.d.ts

@@ -0,0 +1 @@
+export * from './event-manager.constants';

package/controllers/event-participant.controller.d.ts

@@ -0,0 +1,31 @@
+import { ListResponseDto, MessageResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { CreateEventParticipantDto, EventParticipantResponseDto, UpdateParticipantStatusDto, UpdateEventParticipantDto } from '../dtos';
+import { EventParticipantService } from '../services/event-participant.service';
+declare const EventParticipantController_base: abstract new (service: EventParticipantService) => {
+    service: EventParticipantService;
+    insert(addDto: CreateEventParticipantDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EventParticipantResponseDto>>;
+    insertMany(addDto: CreateEventParticipantDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<EventParticipantResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared/dtos").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EventParticipantResponseDto>>;
+    update(updateDto: UpdateEventParticipantDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EventParticipantResponseDto>>;
+    updateMany(updateDtos: UpdateEventParticipantDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<EventParticipantResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared/dtos").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<ListResponseDto<EventParticipantResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared/dtos").DeleteDto, user: ILoggedUserInfo | null): Promise<MessageResponseDto>;
+};
+export declare class EventParticipantController extends EventParticipantController_base {
+    protected participantService: EventParticipantService;
+    constructor(participantService: EventParticipantService);
+    updateStatus(dto: UpdateParticipantStatusDto, user: ILoggedUserInfo): Promise<SingleResponseDto<EventParticipantResponseDto>>;
+    getByEvent(body: {
+        eventId: string;
+    }, user: ILoggedUserInfo): Promise<ListResponseDto<EventParticipantResponseDto>>;
+    getByUser(body: {
+        userId: string;
+    }, user: ILoggedUserInfo): Promise<ListResponseDto<EventParticipantResponseDto>>;
+    removeParticipant(body: {
+        eventId: string;
+        userId: string;
+    }, user: ILoggedUserInfo): Promise<MessageResponseDto>;
+    private buildListResponse;
+}
+export {};

package/controllers/event.controller.d.ts

@@ -0,0 +1,24 @@
+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 { EventService } from '../services/event.service';
+declare const EventController_base: abstract new (service: EventService) => {
+    service: EventService;
+    insert(addDto: CreateEventDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EventResponseDto>>;
+    insertMany(addDto: CreateEventDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<EventResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared/dtos").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EventResponseDto>>;
+    update(updateDto: UpdateEventDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<EventResponseDto>>;
+    updateMany(updateDtos: UpdateEventDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<EventResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared/dtos").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<ListResponseDto<EventResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared/dtos").DeleteDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").MessageResponseDto>;
+};
+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[]>>;
+}
+export {};

package/controllers/index.d.ts

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