@rytass/bpm-core-nestjs-module 0.4.0 → 0.5.0

package/src/lib/notification/notification.service.js

@@ -1,713 +0,0 @@
-"use strict";
-var NotificationService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationService = void 0;
-exports.calculateTaskSlaDueAt = calculateTaskSlaDueAt;
-const tslib_1 = require("tslib");
-const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
-const typeorm_1 = require("@nestjs/typeorm");
-const typeorm_2 = require("typeorm");
-const iso_duration_1 = require("../common/iso-duration");
-const activity_log_entity_1 = require("../workflow-engine/activity-log.entity");
-const approval_instance_entity_1 = require("../workflow-engine/approval-instance.entity");
-const organization_service_1 = require("../organization/organization.service");
-const task_candidate_entity_1 = require("../workflow-engine/task-candidate.entity");
-const task_entity_1 = require("../workflow-engine/task.entity");
-const workflow_engine_tokens_1 = require("../workflow-engine/workflow-engine.tokens");
-const workflow_engine_enums_1 = require("../workflow-engine/workflow-engine.enums");
-const notification_delivery_service_1 = require("./notification-delivery.service");
-const notification_preference_entity_1 = require("./notification-preference.entity");
-const notification_entity_1 = require("./notification.entity");
-const notification_enums_1 = require("./notification.enums");
-const ACTIONABLE_NOTIFICATION_TYPES = [
-    notification_enums_1.NotificationTypeEnum.TASK_ASSIGNED,
-    notification_enums_1.NotificationTypeEnum.TASK_TRANSFERRED,
-];
-const notification_options_1 = require("./notification-options");
-const notification_template_1 = require("./notification-template");
-let NotificationService = NotificationService_1 = class NotificationService {
-    constructor(notificationRepository, notificationPreferenceRepository, taskRepository, taskCandidateRepository, approvalInstanceRepository, activityLogRepository, deliveryService, moduleRef, notificationOptions = notification_options_1.DEFAULT_BPM_NOTIFICATION_OPTIONS) {
-        this.notificationRepository = notificationRepository;
-        this.notificationPreferenceRepository = notificationPreferenceRepository;
-        this.taskRepository = taskRepository;
-        this.taskCandidateRepository = taskCandidateRepository;
-        this.approvalInstanceRepository = approvalInstanceRepository;
-        this.activityLogRepository = activityLogRepository;
-        this.deliveryService = deliveryService;
-        this.moduleRef = moduleRef;
-        this.notificationOptions = notificationOptions;
-        this.logger = new common_1.Logger(NotificationService_1.name);
-    }
-    async listNotifications({ includeRead = false, page = 1, pageSize = 10, recipientMemberId, }) {
-        const normalizedPageSize = normalizePageSize(pageSize);
-        return this.notificationRepository.find({
-            order: { createdAt: 'DESC' },
-            skip: (normalizePage(page) - 1) * normalizedPageSize,
-            take: normalizedPageSize,
-            where: {
-                channel: notification_enums_1.NotificationChannelEnum.IN_APP,
-                recipientMemberId,
-                ...(includeRead ? {} : { status: (0, typeorm_2.Not)(notification_enums_1.NotificationStatusEnum.READ) }),
-            },
-        });
-    }
-    async countNotifications({ includeRead = false, recipientMemberId, }) {
-        return this.notificationRepository.count({
-            where: {
-                channel: notification_enums_1.NotificationChannelEnum.IN_APP,
-                recipientMemberId,
-                ...(includeRead ? {} : { status: (0, typeorm_2.Not)(notification_enums_1.NotificationStatusEnum.READ) }),
-            },
-        });
-    }
-    async countUnreadNotifications(recipientMemberId) {
-        return this.notificationRepository.count({
-            where: {
-                channel: notification_enums_1.NotificationChannelEnum.IN_APP,
-                recipientMemberId,
-                status: (0, typeorm_2.Not)(notification_enums_1.NotificationStatusEnum.READ),
-            },
-        });
-    }
-    async markAllNotificationsRead({ recipientMemberId, }) {
-        const trimmedRecipientMemberId = recipientMemberId.trim();
-        if (!trimmedRecipientMemberId) {
-            return 0;
-        }
-        const result = await this.notificationRepository.update({
-            channel: notification_enums_1.NotificationChannelEnum.IN_APP,
-            recipientMemberId: trimmedRecipientMemberId,
-            status: (0, typeorm_2.Not)(notification_enums_1.NotificationStatusEnum.READ),
-        }, {
-            readAt: new Date(),
-            status: notification_enums_1.NotificationStatusEnum.READ,
-        });
-        return result.affected ?? 0;
-    }
-    async markNotificationRead({ id, readerMemberId, }) {
-        const notification = await this.notificationRepository.findOne({
-            where: { id },
-        });
-        if (!notification) {
-            throw new common_1.NotFoundException(`Notification ${id} was not found`);
-        }
-        if (readerMemberId &&
-            notification.recipientMemberId !== readerMemberId.trim()) {
-            throw new common_1.NotFoundException(`Notification ${id} was not found`);
-        }
-        return this.notificationRepository.save(this.notificationRepository.create({
-            ...notification,
-            readAt: notification.readAt ?? new Date(),
-            status: notification_enums_1.NotificationStatusEnum.READ,
-        }));
-    }
-    async getPreference(memberId) {
-        const existingPreference = await this.notificationPreferenceRepository.findOne({
-            where: { memberId },
-        });
-        return (existingPreference ??
-            createDefaultPreference(memberId, this.notificationOptions));
-    }
-    async updatePreference(input) {
-        const currentPreference = await this.getPreference(input.memberId);
-        return this.notificationPreferenceRepository.save({
-            ...currentPreference,
-            emailDigestMode: input.emailDigestMode,
-            emailEnabled: input.emailEnabled,
-            inAppEnabled: input.inAppEnabled,
-            memberId: input.memberId,
-            quietHoursEnd: normalizeTimeInput(input.quietHoursEnd),
-            quietHoursStart: normalizeTimeInput(input.quietHoursStart),
-        });
-    }
-    async createTaskAssignedNotification({ instance, manager, node, task, transferred = false, }) {
-        if (!task.assigneeMemberId) {
-            return [];
-        }
-        return this.createNotifications({
-            channels: readNodeNotificationChannels(node, this.notificationOptions),
-            customTemplate: node.data.notification?.customTemplate ?? null,
-            instanceId: instance.id,
-            payload: {
-                assigneeMemberId: task.assigneeMemberId,
-                instanceId: instance.id,
-                instanceTitle: instance.title,
-                nodeId: node.id,
-                nodeLabel: node.data.label,
-                originalAssigneeMemberId: task.originalAssigneeMemberId,
-                slaDueAt: task.slaDueAt?.toISOString() ?? null,
-                taskId: task.id,
-            },
-            recipientMemberId: task.assigneeMemberId,
-            taskId: task.id,
-            type: transferred
-                ? notification_enums_1.NotificationTypeEnum.TASK_TRANSFERRED
-                : notification_enums_1.NotificationTypeEnum.TASK_ASSIGNED,
-        }, manager);
-    }
-    async createServiceTaskNotifications({ instance, manager, node, recipientMemberIds, }) {
-        if (node.data.action.type !== 'NOTIFY') {
-            return [];
-        }
-        const action = node.data.action;
-        const channels = normalizeNotificationChannels(action.channels);
-        const uniqueRecipientMemberIds = uniqueStrings(recipientMemberIds);
-        return uniqueRecipientMemberIds.reduce(async (previousPromise, recipientMemberId) => {
-            const previous = await previousPromise;
-            const created = await this.createNotifications({
-                channels,
-                customTemplate: action.template ?? null,
-                instanceId: instance.id,
-                payload: {
-                    instanceId: instance.id,
-                    instanceTitle: instance.title,
-                    message: action.template ??
-                        `案件 ${instance.title} 的 ${node.data.label} 已送出通知。`,
-                    nodeId: node.id,
-                    nodeLabel: node.data.label,
-                    recipientMemberId,
-                },
-                recipientMemberId,
-                taskId: null,
-                type: notification_enums_1.NotificationTypeEnum.WORKFLOW_NOTIFICATION,
-            }, manager);
-            return [...previous, ...created];
-        }, Promise.resolve([]));
-    }
-    /**
-     * Deliver an ad-hoc directive notification (STAGE_NOTIFY /
-     * COMPLETION_NOTIFY) to resolved member recipients. Runs inside the
-     * caller's transaction `manager` so it commits atomically with the
-     * workflow state change that triggered it.
-     */
-    async createAdhocWorkflowNotifications({ channels, instance, manager, message, payload, recipientMemberIds, }) {
-        const normalizedChannels = channels?.length
-            ? channels
-            : [notification_enums_1.NotificationChannelEnum.IN_APP];
-        const uniqueRecipientMemberIds = uniqueStrings(recipientMemberIds);
-        return uniqueRecipientMemberIds.reduce(async (previousPromise, recipientMemberId) => {
-            const previous = await previousPromise;
-            const created = await this.createNotifications({
-                channels: normalizedChannels,
-                instanceId: instance.id,
-                payload: {
-                    ...payload,
-                    instanceId: instance.id,
-                    instanceTitle: instance.title,
-                    message,
-                    recipientMemberId,
-                },
-                recipientMemberId,
-                taskId: null,
-                type: notification_enums_1.NotificationTypeEnum.WORKFLOW_NOTIFICATION,
-            }, manager);
-            return [...previous, ...created];
-        }, Promise.resolve([]));
-    }
-    async createInstanceCompletedNotification({ instance, manager, }) {
-        const repository = manager.getRepository(notification_entity_1.NotificationEntity);
-        const existingNotification = await repository.findOne({
-            where: {
-                channel: notification_enums_1.NotificationChannelEnum.IN_APP,
-                instanceId: instance.id,
-                recipientMemberId: instance.initiatorMemberId,
-                taskId: (0, typeorm_2.IsNull)(),
-                type: notification_enums_1.NotificationTypeEnum.INSTANCE_COMPLETED,
-            },
-        });
-        if (existingNotification) {
-            return [];
-        }
-        return this.createNotifications({
-            channels: [notification_enums_1.NotificationChannelEnum.IN_APP],
-            instanceId: instance.id,
-            payload: {
-                completedAt: instance.completedAt?.toISOString() ?? null,
-                instanceId: instance.id,
-                instanceTitle: instance.title,
-                recipientMemberId: instance.initiatorMemberId,
-            },
-            recipientMemberId: instance.initiatorMemberId,
-            taskId: null,
-            type: notification_enums_1.NotificationTypeEnum.INSTANCE_COMPLETED,
-        }, manager);
-    }
-    /**
-     * Resolve the open task-assignment notifications for a decided task, so the
-     * inline 同意/拒絕 actions stop being offered once the task no longer needs
-     * the recipient. The acting member's notification records the actual
-     * decision (`resolution`); every other candidate's notification is marked
-     * `SUPERSEDED` when the task has ended. Runs inside the caller's
-     * transaction `manager` so it commits atomically with the decision.
-     */
-    async resolveTaskNotifications({ actingMemberId, manager, resolution, supersedeOthers, taskId, }) {
-        const repository = manager.getRepository(notification_entity_1.NotificationEntity);
-        const resolvedAt = new Date();
-        await repository.update({
-            recipientMemberId: actingMemberId,
-            resolvedAt: (0, typeorm_2.IsNull)(),
-            taskId,
-            type: (0, typeorm_2.In)(ACTIONABLE_NOTIFICATION_TYPES),
-        }, {
-            readAt: resolvedAt,
-            resolution,
-            resolvedAt,
-            status: notification_enums_1.NotificationStatusEnum.READ,
-        });
-        if (supersedeOthers) {
-            await repository.update({
-                recipientMemberId: (0, typeorm_2.Not)(actingMemberId),
-                resolvedAt: (0, typeorm_2.IsNull)(),
-                taskId,
-                type: (0, typeorm_2.In)(ACTIONABLE_NOTIFICATION_TYPES),
-            }, {
-                readAt: resolvedAt,
-                resolution: notification_enums_1.NotificationResolutionEnum.SUPERSEDED,
-                resolvedAt,
-                status: notification_enums_1.NotificationStatusEnum.READ,
-            });
-        }
-    }
-    /**
-     * Mark every still-open task-assignment notification for an instance as
-     * `SUPERSEDED` — used when the whole instance is cancelled, so lingering
-     * "待簽" notifications can no longer be actioned. Runs inside the caller's
-     * transaction `manager`.
-     */
-    async supersedeInstanceTaskNotifications({ instanceId, manager, }) {
-        const repository = manager.getRepository(notification_entity_1.NotificationEntity);
-        const resolvedAt = new Date();
-        await repository.update({
-            instanceId,
-            resolvedAt: (0, typeorm_2.IsNull)(),
-            type: (0, typeorm_2.In)(ACTIONABLE_NOTIFICATION_TYPES),
-        }, {
-            readAt: resolvedAt,
-            resolution: notification_enums_1.NotificationResolutionEnum.SUPERSEDED,
-            resolvedAt,
-            status: notification_enums_1.NotificationStatusEnum.READ,
-        });
-    }
-    async runSlaScan(now = new Date()) {
-        const candidateTasks = await this.taskRepository.find({
-            order: { slaDueAt: 'ASC' },
-            where: [
-                {
-                    slaDueAt: (0, typeorm_2.LessThanOrEqual)(now),
-                    status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
-                },
-                {
-                    slaDueAt: (0, typeorm_2.LessThanOrEqual)(now),
-                    status: workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS,
-                },
-                {
-                    slaDueAt: (0, typeorm_2.MoreThan)(now),
-                    status: workflow_engine_enums_1.TaskStatusEnum.PENDING,
-                },
-                {
-                    slaDueAt: (0, typeorm_2.MoreThan)(now),
-                    status: workflow_engine_enums_1.TaskStatusEnum.IN_PROGRESS,
-                },
-            ],
-        });
-        const results = await candidateTasks.reduce(async (resultPromise, task) => {
-            const currentResult = await resultPromise;
-            if (!(await this.tryClaimSlaTask(task.id))) {
-                return currentResult;
-            }
-            const instance = await this.approvalInstanceRepository.findOne({
-                where: { id: task.instanceId },
-            });
-            if (!instance) {
-                return currentResult;
-            }
-            const node = readUserTaskNode(instance, task.nodeId);
-            if (!node?.data.sla || !task.slaDueAt) {
-                return currentResult;
-            }
-            if (task.slaDueAt.getTime() <= now.getTime()) {
-                const created = await this.createSlaNotificationOnce({
-                    instance,
-                    node,
-                    task,
-                    type: notification_enums_1.NotificationTypeEnum.SLA_OVERDUE,
-                });
-                if (created) {
-                    await this.recordSlaActivity({
-                        instance,
-                        node,
-                        task,
-                        trigger: 'OVERDUE',
-                    });
-                    await this.runSlaTimeoutHook({ instance, node, task });
-                }
-                return {
-                    overdueCount: currentResult.overdueCount + (created ? 1 : 0),
-                    warningCount: currentResult.warningCount,
-                };
-            }
-            const warningAt = node.data.sla.warningAt;
-            if (!warningAt || warningAt <= 0 || warningAt >= 1) {
-                return currentResult;
-            }
-            const warningAtTime = task.createdAt.getTime() +
-                (task.slaDueAt.getTime() - task.createdAt.getTime()) * warningAt;
-            if (warningAtTime > now.getTime()) {
-                return currentResult;
-            }
-            const created = await this.createSlaNotificationOnce({
-                instance,
-                node,
-                task,
-                type: notification_enums_1.NotificationTypeEnum.SLA_WARNING,
-            });
-            if (created) {
-                await this.recordSlaActivity({
-                    instance,
-                    node,
-                    task,
-                    trigger: 'WARNING',
-                });
-            }
-            return {
-                overdueCount: currentResult.overdueCount,
-                warningCount: currentResult.warningCount + (created ? 1 : 0),
-            };
-        }, Promise.resolve({ overdueCount: 0, warningCount: 0 }));
-        return results;
-    }
-    async tryClaimSlaTask(taskId) {
-        if (!this.taskRepository.query) {
-            return true;
-        }
-        const rows = (await this.taskRepository.query('SELECT pg_try_advisory_xact_lock(hashtext($1)) AS claimed', [`bpm-sla:${taskId}`]));
-        return rows[0]?.claimed !== false;
-    }
-    async createSlaNotificationOnce({ instance, node, task, type, }) {
-        const recipientMemberIds = await this.resolveTaskRecipientMemberIds(task);
-        if (recipientMemberIds.length === 0) {
-            return false;
-        }
-        const createdNotifications = await recipientMemberIds.reduce(async (countPromise, recipientMemberId) => {
-            const count = await countPromise;
-            const existingNotification = await this.notificationRepository.findOne({
-                where: {
-                    channel: notification_enums_1.NotificationChannelEnum.IN_APP,
-                    recipientMemberId,
-                    taskId: task.id,
-                    type,
-                },
-            });
-            if (existingNotification) {
-                return count;
-            }
-            try {
-                await this.createNotifications({
-                    channels: [notification_enums_1.NotificationChannelEnum.IN_APP],
-                    customTemplate: node.data.notification?.customTemplate ?? null,
-                    instanceId: instance.id,
-                    payload: {
-                        assigneeMemberId: task.assigneeMemberId,
-                        instanceId: instance.id,
-                        instanceTitle: instance.title,
-                        nodeId: node.id,
-                        nodeLabel: node.data.label,
-                        onTimeout: node.data.sla?.onTimeout ?? 'REMIND',
-                        recipientMemberId,
-                        slaDueAt: task.slaDueAt?.toISOString() ?? null,
-                        taskId: task.id,
-                    },
-                    recipientMemberId,
-                    taskId: task.id,
-                    type,
-                });
-            }
-            catch (error) {
-                if (isUniqueConstraintViolation(error)) {
-                    return count;
-                }
-                throw error;
-            }
-            return count + 1;
-        }, Promise.resolve(0));
-        return createdNotifications > 0;
-    }
-    async createNotifications(input, manager) {
-        const preference = await this.getPreference(input.recipientMemberId);
-        const repository = manager
-            ? manager.getRepository(notification_entity_1.NotificationEntity)
-            : this.notificationRepository;
-        const notifications = input.channels.flatMap((channel) => isChannelEnabled(channel, preference, this.notificationOptions)
-            ? [
-                createNotificationEntity({
-                    channel,
-                    input,
-                    options: this.notificationOptions,
-                    repository,
-                }),
-            ]
-            : []);
-        if (notifications.length === 0) {
-            return [];
-        }
-        const savedNotifications = await repository.save(notifications);
-        await Promise.all(savedNotifications
-            .filter((notification) => notification.channel !== notification_enums_1.NotificationChannelEnum.IN_APP)
-            .map((notification) => manager
-            ? Promise.resolve(false)
-            : this.deliveryService.deliverNotification(notification, this.notificationOptions)));
-        return savedNotifications;
-    }
-    async recordSlaActivity({ instance, node, task, trigger, }) {
-        await this.activityLogRepository.save(this.activityLogRepository.create({
-            actorMemberId: null,
-            eventType: workflow_engine_enums_1.ActivityLogEventTypeEnum.SLA_TRIGGERED,
-            instanceId: instance.id,
-            nodeId: task.nodeId,
-            payload: {
-                assigneeMemberId: task.assigneeMemberId,
-                nodeLabel: node.data.label,
-                onTimeout: node.data.sla?.onTimeout ?? 'REMIND',
-                slaDueAt: task.slaDueAt?.toISOString() ?? null,
-                trigger,
-            },
-            taskId: task.id,
-        }));
-    }
-    async runSlaTimeoutHook({ instance, node, task, }) {
-        const timeoutAction = node.data.sla?.onTimeout ?? 'REMIND';
-        if (!isSlaTimeoutActionEnabled(timeoutAction, this.notificationOptions)) {
-            return;
-        }
-        await this.executeSlaTimeoutAction({
-            instance,
-            node,
-            task,
-            timeoutAction,
-        });
-    }
-    async executeSlaTimeoutAction({ instance, node, task, timeoutAction, }) {
-        if (timeoutAction === 'REMIND') {
-            this.logger.log(`SLA reminder processed for task ${task.id}`);
-            return;
-        }
-        const workflowEngine = this.moduleRef.get(workflow_engine_tokens_1.BPM_WORKFLOW_ENGINE_SERVICE, { strict: false });
-        if (timeoutAction === 'AUTO_APPROVE') {
-            const actorMemberId = await this.resolveTaskActorMemberId(task);
-            await workflowEngine.decideTask({
-                action: workflow_engine_enums_1.TaskDecisionActionEnum.APPROVED,
-                comment: 'SLA timeout auto-approved this task.',
-                decidedByMemberId: actorMemberId,
-                taskId: task.id,
-            });
-            return;
-        }
-        if (timeoutAction === 'ESCALATE') {
-            const actorMemberId = await this.resolveTaskActorMemberId(task);
-            const targetMemberId = await this.resolveEscalationTargetMemberId({
-                actorMemberId,
-                node,
-            });
-            if (!targetMemberId || targetMemberId === actorMemberId) {
-                this.logger.warn(`SLA escalation skipped for task ${task.id}`);
-                return;
-            }
-            await workflowEngine.decideTask({
-                action: workflow_engine_enums_1.TaskDecisionActionEnum.TRANSFERRED,
-                comment: 'SLA timeout escalated this task.',
-                decidedByMemberId: actorMemberId,
-                taskId: task.id,
-                transferToMemberId: targetMemberId,
-            });
-            return;
-        }
-        await workflowEngine.cancelApprovalInstance({
-            cancelledByMemberId: instance.initiatorMemberId,
-            comment: 'SLA timeout terminated this instance.',
-            instanceId: instance.id,
-        });
-    }
-    async resolveTaskActorMemberId(task) {
-        if (task.assigneeMemberId) {
-            return task.assigneeMemberId;
-        }
-        const candidate = await this.taskCandidateRepository.findOne({
-            order: { createdAt: 'ASC' },
-            where: { taskId: task.id },
-        });
-        if (!candidate) {
-            throw new common_1.NotFoundException(`Task ${task.id} has no actor candidate`);
-        }
-        return candidate.memberId;
-    }
-    async resolveTaskRecipientMemberIds(task) {
-        if (task.assigneeMemberId) {
-            return [task.assigneeMemberId];
-        }
-        const candidates = await this.taskCandidateRepository.find({
-            order: { createdAt: 'ASC' },
-            where: { taskId: task.id },
-        });
-        return uniqueStrings(candidates
-            .filter((candidate) => candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.PENDING ||
-            candidate.status === workflow_engine_enums_1.TaskCandidateStatusEnum.CLAIMED)
-            .map((candidate) => candidate.memberId));
-    }
-    async resolveEscalationTargetMemberId({ actorMemberId, node, }) {
-        const organizationService = this.moduleRef.get(organization_service_1.OrganizationService, {
-            strict: false,
-        });
-        const levelsUp = Math.max(node.data.sla?.escalateLevelsUp ?? 1, 1);
-        let currentMemberId = actorMemberId;
-        for (let level = 0; level < levelsUp && currentMemberId; level += 1) {
-            currentMemberId =
-                await organizationService.resolveManagerMemberId(currentMemberId);
-        }
-        return currentMemberId;
-    }
-};
-exports.NotificationService = NotificationService;
-exports.NotificationService = NotificationService = NotificationService_1 = tslib_1.__decorate([
-    (0, common_1.Injectable)(),
-    tslib_1.__param(0, (0, typeorm_1.InjectRepository)(notification_entity_1.NotificationEntity)),
-    tslib_1.__param(1, (0, typeorm_1.InjectRepository)(notification_preference_entity_1.NotificationPreferenceEntity)),
-    tslib_1.__param(2, (0, typeorm_1.InjectRepository)(task_entity_1.TaskEntity)),
-    tslib_1.__param(3, (0, typeorm_1.InjectRepository)(task_candidate_entity_1.TaskCandidateEntity)),
-    tslib_1.__param(4, (0, typeorm_1.InjectRepository)(approval_instance_entity_1.ApprovalInstanceEntity)),
-    tslib_1.__param(5, (0, typeorm_1.InjectRepository)(activity_log_entity_1.ActivityLogEntity)),
-    tslib_1.__param(8, (0, common_1.Optional)()),
-    tslib_1.__param(8, (0, common_1.Inject)(notification_options_1.BPM_NOTIFICATION_OPTIONS)),
-    tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
-        typeorm_2.Repository,
-        typeorm_2.Repository,
-        typeorm_2.Repository,
-        typeorm_2.Repository,
-        typeorm_2.Repository,
-        notification_delivery_service_1.NotificationDeliveryService,
-        core_1.ModuleRef, Object])
-], NotificationService);
-function calculateTaskSlaDueAt({ node, now, }) {
-    const duration = node.data.sla?.duration;
-    if (!duration) {
-        return null;
-    }
-    const durationMs = (0, iso_duration_1.parseIsoDurationToMilliseconds)(duration);
-    return durationMs ? new Date(now.getTime() + durationMs) : null;
-}
-function createDefaultPreference(memberId, options) {
-    return Object.assign(new notification_preference_entity_1.NotificationPreferenceEntity(), {
-        emailDigestMode: options.defaultEmailDigestMode,
-        emailEnabled: options.defaultEmailPreferenceEnabled,
-        inAppEnabled: options.defaultInAppPreferenceEnabled,
-        memberId,
-        quietHoursEnd: null,
-        quietHoursStart: null,
-        updatedAt: new Date(0),
-    });
-}
-function normalizeTimeInput(value) {
-    const trimmedValue = value?.trim() ?? '';
-    return trimmedValue || null;
-}
-function readNodeNotificationChannels(node, options) {
-    const configuredChannels = node.data.notification?.channels ?? [];
-    const channels = configuredChannels
-        .map((channel) => channel === 'EMAIL'
-        ? notification_enums_1.NotificationChannelEnum.EMAIL
-        : channel === 'WEBHOOK'
-            ? notification_enums_1.NotificationChannelEnum.WEBHOOK
-            : channel === 'IN_APP'
-                ? notification_enums_1.NotificationChannelEnum.IN_APP
-                : null)
-        .filter((channel) => Boolean(channel));
-    return channels.length ? channels : options.defaultChannels;
-}
-function normalizeNotificationChannels(channels) {
-    const normalizedChannels = channels
-        .map((channel) => channel === notification_enums_1.NotificationChannelEnum.EMAIL
-        ? notification_enums_1.NotificationChannelEnum.EMAIL
-        : channel === notification_enums_1.NotificationChannelEnum.IN_APP
-            ? notification_enums_1.NotificationChannelEnum.IN_APP
-            : null)
-        .filter((channel) => Boolean(channel));
-    return normalizedChannels.length
-        ? normalizedChannels
-        : [notification_enums_1.NotificationChannelEnum.IN_APP];
-}
-function uniqueStrings(values) {
-    return Array.from(new Set(values));
-}
-function isUniqueConstraintViolation(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        error.code === '23505');
-}
-function isChannelEnabled(channel, preference, options) {
-    if (channel === notification_enums_1.NotificationChannelEnum.IN_APP) {
-        return options.inAppEnabled && preference.inAppEnabled;
-    }
-    if (channel === notification_enums_1.NotificationChannelEnum.EMAIL) {
-        return options.emailEnabled && preference.emailEnabled;
-    }
-    return options.webhookEnabled;
-}
-function isSlaTimeoutActionEnabled(action, options) {
-    if (action === 'AUTO_APPROVE') {
-        return options.slaTimeoutAutoApproveEnabled;
-    }
-    if (action === 'ESCALATE') {
-        return options.slaTimeoutEscalateEnabled;
-    }
-    if (action === 'TERMINATE_INSTANCE') {
-        return options.slaTimeoutTerminateInstanceEnabled;
-    }
-    return options.slaTimeoutRemindEnabled;
-}
-function createNotificationEntity({ channel, input, options, repository, }) {
-    const renderedTemplate = (0, notification_template_1.renderNotificationTemplate)({
-        customTemplate: input.customTemplate,
-        engine: options.templateEngine,
-        payload: input.payload,
-        type: input.type,
-    });
-    const isInApp = channel === notification_enums_1.NotificationChannelEnum.IN_APP;
-    return repository.create({
-        attemptCount: 0,
-        body: renderedTemplate.body,
-        channel,
-        deliveredAt: isInApp ? new Date() : null,
-        deliveryError: null,
-        deliveryTarget: null,
-        instanceId: input.instanceId,
-        lastAttemptAt: null,
-        nextRetryAt: null,
-        payload: input.payload,
-        readAt: null,
-        recipientMemberId: input.recipientMemberId,
-        resolution: null,
-        resolvedAt: null,
-        sentAt: isInApp ? new Date() : null,
-        status: isInApp
-            ? notification_enums_1.NotificationStatusEnum.SENT
-            : notification_enums_1.NotificationStatusEnum.PENDING,
-        taskId: input.taskId,
-        title: renderedTemplate.title,
-        type: input.type,
-    });
-}
-function readUserTaskNode(instance, nodeId) {
-    const node = instance.workflowSnapshot.nodes.find((candidate) => candidate.id === nodeId);
-    return node?.type === 'userTask' ? node : null;
-}
-function normalizePage(page) {
-    return Number.isInteger(page) && page > 0 ? page : 1;
-}
-function normalizePageSize(pageSize) {
-    if (!Number.isInteger(pageSize)) {
-        return 10;
-    }
-    return Math.min(Math.max(pageSize, 1), 100);
-}
-//# sourceMappingURL=notification.service.js.map