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

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

@@ -0,0 +1,713 @@
+"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