opencrm/backend/dist/services/contractTask.service.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getTasksByContract = getTasksByContract;
exports.getTaskById = getTaskById;
exports.createTask = createTask;
exports.updateTask = updateTask;
exports.completeTask = completeTask;
exports.reopenTask = reopenTask;
exports.deleteTask = deleteTask;
exports.createSubtask = createSubtask;
exports.updateSubtask = updateSubtask;
exports.completeSubtask = completeSubtask;
exports.reopenSubtask = reopenSubtask;
exports.deleteSubtask = deleteSubtask;
exports.getSubtaskById = getSubtaskById;
exports.getAllTasks = getAllTasks;
exports.getTaskStats = getTaskStats;
const client_1 = require("@prisma/client");
const prisma = new client_1.PrismaClient();
async function getTasksByContract(filters) {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const where = {
        contractId: filters.contractId,
    };
    if (filters.status) {
        where.status = filters.status;
    }
    // Spezielle Logik für Kundenportal
    if (filters.customerPortalEmails && filters.customerPortalEmails.length > 0) {
        // Zeige Tasks die:
        // 1. visibleInPortal = true ODER
        // 2. vom Kunden selbst erstellt wurden (createdBy in customerPortalEmails)
        where.OR = [
            { visibleInPortal: true },
            { createdBy: { in: filters.customerPortalEmails } },
        ];
    }
    else if (filters.visibleInPortal !== undefined) {
        where.visibleInPortal = filters.visibleInPortal;
    }
    return prisma.contractTask.findMany({
        where,
        include: {
            subtasks: {
                orderBy: [
                    { status: 'asc' },
                    { createdAt: 'asc' },
                ],
            },
        },
        orderBy: [
            { status: 'asc' }, // OPEN first, then COMPLETED
            { createdAt: 'desc' },
        ],
    });
}
async function getTaskById(id) {
    return prisma.contractTask.findUnique({
        where: { id },
    });
}
async function createTask(data) {
    return prisma.contractTask.create({
        data: {
            contractId: data.contractId,
            title: data.title,
            description: data.description,
            visibleInPortal: data.visibleInPortal ?? false,
            createdBy: data.createdBy,
        },
    });
}
async function updateTask(id, data) {
    return prisma.contractTask.update({
        where: { id },
        data,
    });
}
async function completeTask(id) {
    return prisma.contractTask.update({
        where: { id },
        data: {
            status: 'COMPLETED',
            completedAt: new Date(),
        },
    });
}
async function reopenTask(id) {
    return prisma.contractTask.update({
        where: { id },
        data: {
            status: 'OPEN',
            completedAt: null,
        },
    });
}
async function deleteTask(id) {
    return prisma.contractTask.delete({
        where: { id },
    });
}
// ==================== SUBTASKS ====================
async function createSubtask(data) {
    return prisma.contractTaskSubtask.create({
        data: {
            taskId: data.taskId,
            title: data.title,
            createdBy: data.createdBy,
        },
    });
}
async function updateSubtask(id, data) {
    return prisma.contractTaskSubtask.update({
        where: { id },
        data,
    });
}
async function completeSubtask(id) {
    // Complete the subtask
    const subtask = await prisma.contractTaskSubtask.update({
        where: { id },
        data: {
            status: 'COMPLETED',
            completedAt: new Date(),
        },
    });
    // Check if all subtasks of the parent task are now completed
    const remainingOpenSubtasks = await prisma.contractTaskSubtask.count({
        where: {
            taskId: subtask.taskId,
            status: 'OPEN',
        },
    });
    // If no open subtasks remain, automatically complete the parent task
    if (remainingOpenSubtasks === 0) {
        await prisma.contractTask.update({
            where: { id: subtask.taskId },
            data: {
                status: 'COMPLETED',
                completedAt: new Date(),
            },
        });
    }
    return subtask;
}
async function reopenSubtask(id) {
    // Reopen the subtask
    const subtask = await prisma.contractTaskSubtask.update({
        where: { id },
        data: {
            status: 'OPEN',
            completedAt: null,
        },
    });
    // If the parent task was completed, reopen it as well
    const parentTask = await prisma.contractTask.findUnique({
        where: { id: subtask.taskId },
    });
    if (parentTask?.status === 'COMPLETED') {
        await prisma.contractTask.update({
            where: { id: subtask.taskId },
            data: {
                status: 'OPEN',
                completedAt: null,
            },
        });
    }
    return subtask;
}
async function deleteSubtask(id) {
    return prisma.contractTaskSubtask.delete({
        where: { id },
    });
}
async function getSubtaskById(id) {
    return prisma.contractTaskSubtask.findUnique({
        where: { id },
        include: { task: true },
    });
}
async function getAllTasks(filters) {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const where = {};
    if (filters.status) {
        where.status = filters.status;
    }
    // Für Kundenportal: Filter auf erlaubte Verträge + Sichtbarkeit
    if (filters.customerPortalCustomerIds && filters.customerPortalCustomerIds.length > 0) {
        where.contract = {
            customerId: { in: filters.customerPortalCustomerIds },
        };
        // Zeige nur sichtbare Tasks ODER vom Kunden erstellte
        if (filters.customerPortalEmails && filters.customerPortalEmails.length > 0) {
            where.OR = [
                { visibleInPortal: true },
                { createdBy: { in: filters.customerPortalEmails } },
            ];
        }
        else {
            where.visibleInPortal = true;
        }
    }
    else if (filters.customerId) {
        // Für Mitarbeiter: Optional nach Kunde filtern
        where.contract = {
            customerId: filters.customerId,
        };
    }
    return prisma.contractTask.findMany({
        where,
        include: {
            subtasks: {
                orderBy: [
                    { status: 'asc' },
                    { createdAt: 'asc' },
                ],
            },
            contract: {
                select: {
                    id: true,
                    contractNumber: true,
                    customerId: true,
                    customer: {
                        select: {
                            id: true,
                            firstName: true,
                            lastName: true,
                            companyName: true,
                            customerNumber: true,
                        },
                    },
                    provider: {
                        select: {
                            id: true,
                            name: true,
                        },
                    },
                    tariff: {
                        select: {
                            id: true,
                            name: true,
                        },
                    },
                    providerName: true,
                    tariffName: true,
                },
            },
        },
        orderBy: [
            { status: 'asc' }, // OPEN first, then COMPLETED
            { createdAt: 'desc' },
        ],
    });
}
async function getTaskStats(filters) {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const where = {
        status: 'OPEN',
    };
    // Für Kundenportal: Filter auf erlaubte Verträge + Sichtbarkeit
    if (filters.customerPortalCustomerIds && filters.customerPortalCustomerIds.length > 0) {
        where.contract = {
            customerId: { in: filters.customerPortalCustomerIds },
        };
        // Zeige nur sichtbare Tasks ODER vom Kunden erstellte
        if (filters.customerPortalEmails && filters.customerPortalEmails.length > 0) {
            where.OR = [
                { visibleInPortal: true },
                { createdBy: { in: filters.customerPortalEmails } },
            ];
        }
        else {
            where.visibleInPortal = true;
        }
    }
    else if (filters.customerId) {
        where.contract = {
            customerId: filters.customerId,
        };
    }
    const openCount = await prisma.contractTask.count({ where });
    return { openCount };
}
//# sourceMappingURL=contractTask.service.js.map