@flusys/nestjs-event-manager 7.0.2 → 8.0.0-beta.1

package/fesm/833.js

@@ -0,0 +1,840 @@
+import { ListResponseDto, SingleResponseDto } from "@flusys/nestjs-shared/dtos";
+import { JwtAuthGuard, PermissionGuard } from "@flusys/nestjs-shared/guards";
+import * as __rspack_external__flusys_nestjs_shared_interfaces_413f2706 from "@flusys/nestjs-shared/interfaces";
+export const __rspack_esm_id = 833;
+export const __rspack_esm_ids = [833];
+export const __webpack_modules__ = {
+219(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  $: () => (/* reexport */ EventManagerAdapter)
+});
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: ./projects/nestjs-event-manager/src/services/event-manager-helper.service.ts
+var event_manager_helper_service = __webpack_require__(605);
+;// CONCATENATED MODULE: ./projects/nestjs-event-manager/src/adapters/event-manager.adapter.ts
+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(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+class EventManagerAdapter {
+    eventManagerHelper;
+    constructor(eventManagerHelper){
+        this.eventManagerHelper = eventManagerHelper;
+    }
+    async createEvent(options) {
+        return this.eventManagerHelper.createEvent(options);
+    }
+    async updateParticipantStatus(participantId, status) {
+        await this.eventManagerHelper.updateParticipantStatus(participantId, status);
+    }
+    async getEventsForUser(userId, startDate, endDate, companyId) {
+        return this.eventManagerHelper.getEventsForUser(userId, startDate.toISOString().split('T')[0], endDate.toISOString().split('T')[0], companyId);
+    }
+    async getEventById(eventId) {
+        return this.eventManagerHelper.getEventById(eventId);
+    }
+}
+EventManagerAdapter = _ts_decorate([
+    (0,common_.Injectable)(),
+    _ts_param(0, (0,common_.Inject)(event_manager_helper_service/* .EventManagerHelperService */.x)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof event_manager_helper_service/* .EventManagerHelperService */.x === "undefined" ? Object : event_manager_helper_service/* .EventManagerHelperService */.x
+    ])
+], EventManagerAdapter);
+
+;// CONCATENATED MODULE: ./projects/nestjs-event-manager/src/adapters/index.ts
+
+
+
+},
+558(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  d: () => (/* reexport */ EventController)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/classes"
+var classes_ = __webpack_require__(937);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/decorators"
+var decorators_ = __webpack_require__(265);
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/dtos"
+
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/guards"
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: external "@nestjs/swagger"
+var swagger_ = __webpack_require__(176);
+// EXTERNAL MODULE: external "class-transformer"
+var external_class_transformer_ = __webpack_require__(812);
+// EXTERNAL MODULE: ./projects/nestjs-event-manager/src/config/message-keys.ts
+var message_keys = __webpack_require__(401);
+// EXTERNAL MODULE: ./projects/nestjs-event-manager/src/docs/index.ts + 1 modules
+var docs = __webpack_require__(283);
+// EXTERNAL MODULE: ./projects/nestjs-event-manager/src/dtos/index.ts + 4 modules
+var dtos = __webpack_require__(178);
+// EXTERNAL MODULE: ./projects/nestjs-event-manager/src/services/event.service.ts + 1 modules
+var event_service = __webpack_require__(332);
+;// CONCATENATED MODULE: ./projects/nestjs-event-manager/src/controllers/event.controller.ts
+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(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+class EventController extends (0,classes_.createApiController)(dtos/* .CreateEventDto */.wJ, dtos/* .UpdateEventDto */.XJ, dtos/* .EventResponseDto */.XZ, {
+    entityName: 'event',
+    security: {
+        insert: {
+            level: 'permission',
+            permissions: [
+                docs/* .EVENT_PERMISSIONS.CREATE */.U.CREATE
+            ]
+        },
+        insertMany: {
+            level: 'permission',
+            permissions: [
+                docs/* .EVENT_PERMISSIONS.CREATE */.U.CREATE
+            ]
+        },
+        getById: {
+            level: 'permission',
+            permissions: [
+                docs/* .EVENT_PERMISSIONS.READ */.U.READ
+            ]
+        },
+        getAll: {
+            level: 'permission',
+            permissions: [
+                docs/* .EVENT_PERMISSIONS.READ */.U.READ
+            ]
+        },
+        update: {
+            level: 'permission',
+            permissions: [
+                docs/* .EVENT_PERMISSIONS.UPDATE */.U.UPDATE
+            ]
+        },
+        updateMany: {
+            level: 'permission',
+            permissions: [
+                docs/* .EVENT_PERMISSIONS.UPDATE */.U.UPDATE
+            ]
+        },
+        delete: {
+            level: 'permission',
+            permissions: [
+                docs/* .EVENT_PERMISSIONS.DELETE */.U.DELETE
+            ]
+        }
+    }
+}) {
+    eventService;
+    constructor(eventService){
+        super(eventService), this.eventService = eventService;
+    }
+    async getCalendarEvents(dto, user) {
+        const events = await this.eventService.getEventsForCalendarRange(dto, user);
+        const plainOptions = {
+            excludeExtraneousValues: true
+        };
+        const data = (0,external_class_transformer_.plainToInstance)(dtos/* .CalendarEventResponseDto */.hh, events, plainOptions);
+        return {
+            success: true,
+            message: 'Calendar events retrieved successfully',
+            messageKey: message_keys/* .EVENT_MESSAGES.GET_ALL_SUCCESS */.G.GET_ALL_SUCCESS,
+            data,
+            meta: {
+                total: data.length,
+                page: 0,
+                pageSize: data.length,
+                count: data.length
+            }
+        };
+    }
+    async updateParticipantStatus(dto, user) {
+        const participant = await this.eventService.updateParticipantStatus(dto, user);
+        const plainOptions = {
+            excludeExtraneousValues: true
+        };
+        return {
+            success: true,
+            message: 'Participant status updated successfully',
+            messageKey: message_keys/* .EVENT_PARTICIPANT_MESSAGES.STATUS_UPDATE_SUCCESS */.C.STATUS_UPDATE_SUCCESS,
+            data: (0,external_class_transformer_.plainToInstance)(dtos/* .EventParticipantResponseDto */.KA, participant, plainOptions)
+        };
+    }
+}
+_ts_decorate([
+    (0,common_.Post)('calendar'),
+    (0,common_.UseGuards)(JwtAuthGuard),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,swagger_.ApiOperation)({
+        summary: 'Get events for calendar range with recurrence expansion'
+    }),
+    (0,swagger_.ApiBody)({
+        type: dtos/* .CalendarQueryDto */.it
+    }),
+    (0,swagger_.ApiResponse)({
+        status: 200,
+        description: 'Calendar events retrieved successfully',
+        type: ListResponseDto
+    }),
+    _ts_param(0, (0,common_.Body)()),
+    _ts_param(1, (0,decorators_.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof dtos/* .CalendarQueryDto */.it === "undefined" ? Object : dtos/* .CalendarQueryDto */.it,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EventController.prototype, "getCalendarEvents", null);
+_ts_decorate([
+    (0,common_.Post)('update-participant-status'),
+    (0,common_.UseGuards)(JwtAuthGuard, PermissionGuard),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,decorators_.RequirePermission)(docs/* .EVENT_PERMISSIONS.UPDATE */.U.UPDATE),
+    (0,swagger_.ApiOperation)({
+        summary: 'Update participant status (accept/decline/tentative)'
+    }),
+    (0,swagger_.ApiBody)({
+        type: dtos/* .UpdateParticipantStatusDto */.Wk
+    }),
+    (0,swagger_.ApiResponse)({
+        status: 200,
+        type: SingleResponseDto
+    }),
+    _ts_param(0, (0,common_.Body)()),
+    _ts_param(1, (0,decorators_.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof dtos/* .UpdateParticipantStatusDto */.Wk === "undefined" ? Object : dtos/* .UpdateParticipantStatusDto */.Wk,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EventController.prototype, "updateParticipantStatus", null);
+EventController = _ts_decorate([
+    (0,swagger_.ApiTags)('Events'),
+    (0,common_.Controller)('event-manager/event'),
+    _ts_param(0, (0,common_.Inject)(event_service/* .EventService */.U)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof event_service/* .EventService */.U === "undefined" ? Object : event_service/* .EventService */.U
+    ])
+], EventController);
+
+;// CONCATENATED MODULE: ./projects/nestjs-event-manager/src/controllers/index.ts
+
+
+
+},
+283(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  U: () => (/* reexport */ nestjs_shared_.EVENT_PERMISSIONS),
+  S: () => (/* reexport */ eventManagerSwaggerConfig)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared"
+var nestjs_shared_ = __webpack_require__(422);
+;// CONCATENATED MODULE: ./projects/nestjs-event-manager/src/docs/event-manager-swagger.config.ts
+/** Schema properties to exclude when company feature is disabled */ const COMPANY_SCHEMA_EXCLUSIONS = [
+    {
+        schemaName: 'EventResponseDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'CalendarEventResponseDto',
+        properties: [
+            'companyId'
+        ]
+    }
+];
+function buildDescription(enableCompanyFeature, isMultiTenant) {
+    const multiTenantNote = isMultiTenant ? `\n> **Multi-Tenant Mode**: Include \`x-tenant-id\` header to target a specific tenant database.\n` : '';
+    const companyFeatures = enableCompanyFeature ? '\n- **Company-scoped events**' : '';
+    const companyIsolation = enableCompanyFeature ? '\n- **Company isolation**' : '';
+    const multiTenantSection = enableCompanyFeature ? `
+## Multi-Tenant Support
+
+Events are automatically isolated by:
+- **Company ID**: Events belong to specific companies
+- **User Context**: Participants are company members
+
+All queries automatically filter by current user's company context.
+` : '';
+    return `
+# Event Manager API
+${multiTenantNote}
+Calendar event management with recurrence support${enableCompanyFeature ? ' and multi-tenant capabilities' : ''}.
+
+## Features
+
+### 📅 Event Management
+- Create, read, update, delete events
+- Color-coded events
+- All-day event support${companyFeatures}
+
+### 🔄 Recurrence Support
+- **None**: Single occurrence
+- **Daily**: Every day
+- **Weekly**: Specific days of the week
+- **Biweekly**: Every two weeks
+- **Monthly**: Same day each month
+
+### 👥 Participant Management
+- Status tracking (pending, accepted, declined, tentative)
+- Organizer designation
+
+### 📆 Calendar Queries
+- Date range queries
+- Automatic recurrence expansion
+- Filter by user participation
+- Include/exclude participants in response
+
+### 🔒 Security
+- JWT authentication required
+- Permission-based access control${companyIsolation}
+
+## Recurrence Patterns
+
+### Weekly Recurrence
+Use the \`weekDays\` array to specify which days repeat:
+- \`"SUN"\` = Sunday
+- \`"MON"\` = Monday
+- \`"TUE"\` = Tuesday
+- \`"WED"\` = Wednesday
+- \`"THU"\` = Thursday
+- \`"FRI"\` = Friday
+- \`"SAT"\` = Saturday
+
+Example: \`{ "weekDays": ["MON", "WED", "FRI"] }\` = Monday, Wednesday, Friday
+
+### Recurrence Expansion
+Calendar queries automatically expand recurring events into individual instances.
+Each instance includes:
+- \`isRecurrenceInstance: true\`
+- \`originalEventId\`: Reference to parent event
+${multiTenantSection}
+## API Endpoints
+
+All endpoints use POST method (RPC style):
+
+### Events
+- \`/event-manager/event/insert\` - Create event
+- \`/event-manager/event/get/:id\` - Get by ID
+- \`/event-manager/event/get-all\` - List with pagination
+- \`/event-manager/event/update\` - Update event
+- \`/event-manager/event/delete\` - Soft delete
+- \`/event-manager/event/calendar\` - Calendar query with expansion
+
+### Participant Operations (via Event endpoints)
+- \`/event-manager/event/update-participant-status\` - Update status
+
+## Getting Started
+
+1. **Authenticate**: Obtain JWT token from /auth/login
+2. **Create Event**: POST to /event-manager/event/insert
+3. **Query Calendar**: POST to /event-manager/event/calendar with date range
+`;
+}
+/**
+ * Event Manager Module Swagger Configuration
+ * Use this with setupSwaggerDocs() from @flusys/nestjs-core
+ */ function eventManagerSwaggerConfig(bootstrapConfig) {
+    const enableCompanyFeature = bootstrapConfig?.enableCompanyFeature ?? true;
+    const isMultiTenant = bootstrapConfig?.databaseMode === 'multi-tenant';
+    return {
+        title: 'Event Manager API',
+        description: buildDescription(enableCompanyFeature, isMultiTenant),
+        version: '1.0',
+        path: 'api/docs/event-manager',
+        bearerAuth: true,
+        excludeTags: [],
+        excludeSchemaProperties: enableCompanyFeature ? undefined : COMPANY_SCHEMA_EXCLUSIONS
+    };
+}
+
+;// CONCATENATED MODULE: ./projects/nestjs-event-manager/src/docs/index.ts
+// Re-export permissions from shared for convenience
+
+// Swagger configuration
+
+
+
+},
+120(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  _: () => (/* reexport */ EventManagerModule)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(236);
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/interfaces"
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: ./projects/nestjs-event-manager/src/config/event-manager.constants.ts
+var event_manager_constants = __webpack_require__(890);
+// EXTERNAL MODULE: ./projects/nestjs-event-manager/src/controllers/index.ts + 3 modules
+var controllers = __webpack_require__(558);
+// EXTERNAL MODULE: ./projects/nestjs-event-manager/src/adapters/index.ts + 1 modules
+var adapters = __webpack_require__(219);
+// EXTERNAL MODULE: ./projects/nestjs-event-manager/src/services/index.ts
+var services = __webpack_require__(965);
+;// CONCATENATED MODULE: ./projects/nestjs-event-manager/src/modules/event-manager.module.ts
+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;
+}
+
+
+
+
+
+
+
+const CONTROLLERS = [
+    controllers/* .EventController */.d
+];
+const EXPORTED_SERVICES = [
+    services/* .EventManagerConfigService */.$_,
+    services/* .EventManagerDataSourceProvider */.a1,
+    services/* .EventManagerHelperService */.x_,
+    services/* .EventService */.US
+];
+const ADAPTER_PROVIDER = {
+    provide: __rspack_external__flusys_nestjs_shared_interfaces_413f2706.EVENT_MANAGER_ADAPTER,
+    useClass: adapters/* .EventManagerAdapter */.$
+};
+class EventManagerModule {
+    static forRoot(options) {
+        return {
+            module: EventManagerModule,
+            global: options.global ?? false,
+            imports: [
+                modules_.CacheModule,
+                modules_.UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.buildProviders(options),
+                adapters/* .EventManagerAdapter */.$,
+                ADAPTER_PROVIDER
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                __rspack_external__flusys_nestjs_shared_interfaces_413f2706.EVENT_MANAGER_ADAPTER
+            ]
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: EventManagerModule,
+            global: options.global ?? false,
+            imports: [
+                ...options.imports || [],
+                modules_.CacheModule,
+                modules_.UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...this.buildProviders(),
+                adapters/* .EventManagerAdapter */.$,
+                ADAPTER_PROVIDER
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                __rspack_external__flusys_nestjs_shared_interfaces_413f2706.EVENT_MANAGER_ADAPTER
+            ]
+        };
+    }
+    // Private Helpers
+    static buildProviders(options) {
+        const providers = [
+            ...EXPORTED_SERVICES
+        ];
+        if (options) {
+            providers.unshift({
+                provide: event_manager_constants/* .EVENT_MANAGER_MODULE_OPTIONS */.D,
+                useValue: options
+            });
+        }
+        providers.push((0,modules_.createModuleEventsProvider)('event-manager', event_manager_constants/* .EVENT_MANAGER_MODULE_OPTIONS */.D));
+        return providers;
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: event_manager_constants/* .EVENT_MANAGER_MODULE_OPTIONS */.D,
+                    useFactory: async (...args)=>({
+                            ...options,
+                            config: await options.useFactory(...args)
+                        }),
+                    inject: options.inject || []
+                }
+            ];
+        }
+        const factoryClass = options.useClass || options.useExisting;
+        if (!factoryClass) return [];
+        const providers = [
+            {
+                provide: event_manager_constants/* .EVENT_MANAGER_MODULE_OPTIONS */.D,
+                useFactory: async (factory)=>({
+                        ...options,
+                        config: await factory.createEventManagerOptions()
+                    }),
+                inject: [
+                    factoryClass
+                ]
+            }
+        ];
+        if (options.useClass) {
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass
+            });
+        }
+        return providers;
+    }
+}
+EventManagerModule = _ts_decorate([
+    (0,common_.Module)({})
+], EventManagerModule);
+
+;// CONCATENATED MODULE: ./projects/nestjs-event-manager/src/modules/index.ts
+
+
+
+},
+605(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _config_index_js__rspack_import_9 = __webpack_require__(401);
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(157);
+/* import */ var typeorm__rspack_import_1 = __webpack_require__(158);
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_2 = __webpack_require__(937);
+/* import */ var _flusys_nestjs_shared_decorators__rspack_import_3 = __webpack_require__(265);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_4 = __webpack_require__(236);
+/* import */ var _flusys_nestjs_shared__rspack_import_5 = __webpack_require__(422);
+/* import */ var _event_manager_config_service_js__rspack_import_6 = __webpack_require__(619);
+/* import */ var _event_manager_datasource_provider_js__rspack_import_7 = __webpack_require__(324);
+/* import */ var _entities_index_js__rspack_import_8 = __webpack_require__(80);
+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(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+class EventManagerHelperService {
+    cacheManager;
+    utilsService;
+    configService;
+    dataSourceProvider;
+    eventEntityName = 'event';
+    dataSource = null;
+    constructor(cacheManager, utilsService, configService, dataSourceProvider){
+        this.cacheManager = cacheManager;
+        this.utilsService = utilsService;
+        this.configService = configService;
+        this.dataSourceProvider = dataSourceProvider;
+    }
+    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() ? _entities_index_js__rspack_import_8/* .EventWithCompany */.QO : _entities_index_js__rspack_import_8/* .Event */.Jh;
+        return ds.getRepository(EntityClass);
+    }
+    async getParticipantRepository() {
+        const ds = await this.getDataSource();
+        return ds.getRepository(_entities_index_js__rspack_import_8/* .EventParticipant */.ek);
+    }
+    async createEvent(options) {
+        const repo = await this.getEventRepository();
+        const isAllDay = options.isAllDay ?? false;
+        const entity = {
+            title: options.title,
+            description: options.description ?? null,
+            eventDate: options.eventDate,
+            startTime: isAllDay ? '00:00' : options.startTime,
+            endTime: isAllDay ? '23:59' : options.endTime,
+            isAllDay,
+            recurrenceType: options.recurrenceType ?? _flusys_nestjs_shared__rspack_import_5.RecurrenceType.NONE,
+            recurrenceEndDate: options.recurrenceEndDate ?? null,
+            weekDays: options.weekDays ?? null,
+            color: options.color ?? this.configService.getDefaultColor(),
+            meetingLink: options.meetingLink ?? null,
+            isActive: true
+        };
+        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();
+        return this.toEventResult(saved);
+    }
+    async updateParticipantStatus(participantId, status) {
+        const participantRepo = await this.getParticipantRepository();
+        const participant = await participantRepo.findOne({
+            where: {
+                id: participantId,
+                deletedAt: (0,typeorm__rspack_import_1.IsNull)()
+            }
+        });
+        if (!participant) {
+            throw new _nestjs_common__rspack_import_0.NotFoundException({
+                message: 'Event participant not found',
+                messageKey: _config_index_js__rspack_import_9/* .EVENT_PARTICIPANT_MESSAGES.NOT_FOUND */.C.NOT_FOUND
+            });
+        }
+        participant.status = status;
+        await participantRepo.save(participant);
+    }
+    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.eventDate <= :endDate', {
+            endDate
+        }).andWhere('event.eventDate >= :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: (0,typeorm__rspack_import_1.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: _flusys_nestjs_shared__rspack_import_5.ParticipantStatus.PENDING,
+                isOrganizer: userId === organizerId
+            }));
+        await participantRepo.save(participants);
+    }
+    toEventResult(event) {
+        const eventExt = 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,
+            companyId: eventExt.companyId ?? null,
+            createdAt: event.createdAt,
+            updatedAt: event.updatedAt
+        };
+    }
+    async clearCache() {
+        await this.utilsService.clearCache(this.eventEntityName, this.cacheManager);
+    }
+}
+_ts_decorate([
+    (0,_flusys_nestjs_shared_decorators__rspack_import_3.LogAction)({
+        action: 'event.create',
+        module: 'event-manager'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof CreateEventOptions === "undefined" ? Object : CreateEventOptions
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EventManagerHelperService.prototype, "createEvent", null);
+_ts_decorate([
+    (0,_flusys_nestjs_shared_decorators__rspack_import_3.LogAction)({
+        action: 'eventParticipant.updateStatus',
+        module: 'event-manager'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        typeof _flusys_nestjs_shared__rspack_import_5.ParticipantStatus === "undefined" ? Object : _flusys_nestjs_shared__rspack_import_5.ParticipantStatus
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EventManagerHelperService.prototype, "updateParticipantStatus", null);
+EventManagerHelperService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_0.Injectable)(),
+    _ts_param(0, (0,_nestjs_common__rspack_import_0.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,_nestjs_common__rspack_import_0.Inject)(_flusys_nestjs_shared_modules__rspack_import_4.UtilsService)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_0.Inject)(_event_manager_config_service_js__rspack_import_6/* .EventManagerConfigService */.$)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_0.Inject)(_event_manager_datasource_provider_js__rspack_import_7/* .EventManagerDataSourceProvider */.a)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _flusys_nestjs_shared_classes__rspack_import_2.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_2.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_4.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_4.UtilsService,
+        typeof _event_manager_config_service_js__rspack_import_6/* .EventManagerConfigService */.$ === "undefined" ? Object : _event_manager_config_service_js__rspack_import_6/* .EventManagerConfigService */.$,
+        typeof _event_manager_datasource_provider_js__rspack_import_7/* .EventManagerDataSourceProvider */.a === "undefined" ? Object : _event_manager_datasource_provider_js__rspack_import_7/* .EventManagerDataSourceProvider */.a
+    ])
+], EventManagerHelperService);
+
+__webpack_require__.d(__webpack_exports__, {
+  x: () => (EventManagerHelperService)
+});
+
+
+},
+965(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _event_manager_config_service_js__rspack_import_0 = __webpack_require__(619);
+/* import */ var _event_manager_datasource_provider_js__rspack_import_1 = __webpack_require__(324);
+/* import */ var _event_manager_helper_service_js__rspack_import_2 = __webpack_require__(605);
+/* import */ var _event_service_js__rspack_import_3 = __webpack_require__(332);
+
+
+
+
+
+__webpack_require__.d(__webpack_exports__, {
+  $_: () => (/* reexport safe */ _event_manager_config_service_js__rspack_import_0.$),
+  US: () => (/* reexport safe */ _event_service_js__rspack_import_3.U),
+  a1: () => (/* reexport safe */ _event_manager_datasource_provider_js__rspack_import_1.a),
+  x_: () => (/* reexport safe */ _event_manager_helper_service_js__rspack_import_2.x)
+});
+
+
+},
+
+};