radar_farmagitechs/src/services/admin/VendorExperienceService.js

const HttpException = require('../../utils/HttpException.js');
const prisma = require('../../prisma/PrismaClient.js');
const { SearchFilter } = require('../../utils/SearchFilter.js');
const timeLocal = require('../../utils/TimeLocal.js');
const { createLog, updateLog, deleteLog } = require('../../utils/LogActivity.js');
const { formatDateOnly, formatISOWithoutTimezone } = require('../../utils/FormatDate.js');
const VendorExperienceRepository = require('../../repository/admin/VendorExperienceRepository.js');

exports.getAllVendorHistoryService = async ({ page, limit, search, sortBy, orderBy }, req) => {
    const skip = (page - 1) * limit;

    const hospitalId = req.params.id;
    const hospital = await prisma.hospital.findFirst({
        where: {
            id: hospitalId
        }
    })
    if (!hospital) {
        throw new HttpException("Hospital not found", 404)
    }

    const where = {
        // ...SearchFilter(search, ['name', 'name_pt']),
        hospital_id: req.params.id,
        deletedAt: null
    };

    const [vendor_histories, total] = await Promise.all([
        VendorExperienceRepository.findAll({ skip, take: limit, where, orderBy: { [sortBy]: orderBy } }),
        VendorExperienceRepository.countAll(where)
    ]);

    return { vendor_histories, total };
};

exports.showVendorHistoryService = async (req) => {
    const id_hospital = req.params.id;
    const id_vendor_experience = req.params.id_vendor_experience;

    const hospital = await prisma.hospital.findFirst({
        where: {
            id: id_hospital
        }
    })
    if (!hospital) {
        throw new HttpException("Hospital not found", 404)
    }

    const vendorHistory = await VendorExperienceRepository.findById(id_vendor_experience);
    if (!vendorHistory) {
        throw new HttpException("Vendor history not found", 404);
    }

    return vendorHistory;
};

exports.storeVendorHistoryService = async (validateData, req) => {
    const hospitalId = req.params.id;

    const hospital = await prisma.hospital.findFirst({
        where: {
            id: hospitalId
        }
    });

    if (!hospital) {
        throw new HttpException("Hospital not found", 404)
    }

    if (validateData.vendor_id) {
        const vendor = await prisma.vendor.findFirst({
            where: {
                id: validateData.vendor_id
            }
        });

        if (!vendor) {
            throw new HttpException("Vendor not found", 404)
        }
    }

    const SimrsType = ["vendor", "in house", "gratis"];
    if (validateData.simrs_type && !SimrsType.includes(validateData.simrs_type)) {
        throw new HttpException("Simrs type must be vendor, in house, or gratis", 400);
    }

    if (validateData.contract_start_date && validateData.contract_expired_date) {
        if (validateData.contract_start_date >= validateData.contract_expired_date) {
            throw new HttpException("Contract expired date must be after contract date", 400)
        }
    }

    if (validateData.contract_value_min && validateData.contract_value_max) {
        if (validateData.contract_value_min >= validateData.contract_value_max) {
            throw new HttpException("Contract value max must be after contract value min", 400)
        }
    }

    // await prisma.hospital.update({
    //     where: { id: hospitalId },
    //     data: {
    //         simrs_type: validateData.simrs_type
    //     }
    // });

    if (validateData.simrs_type) {
        const existingActiveVendors = await prisma.vendorExperience.findMany({
            where: {
                hospital_id: hospitalId,
                status: "active",
                deletedAt: null
            }
        });

        if (existingActiveVendors.length > 0) {
            await prisma.vendorExperience.updateMany({
                where: {
                    hospital_id: hospitalId,
                    status: "active",
                    deletedAt: null
                },
                data: {
                    status: "inactive"
                }
            });
        }

        validateData.status = "active";
    }

    const payload = {
        vendor_id: validateData.vendor_id,
        simrs_type: validateData.simrs_type,
        status: validateData.status,
        contract_start_date: validateData.contract_start_date ? new Date(validateData.contract_start_date) : null,
        contract_expired_date: validateData.contract_expired_date ? new Date(validateData.contract_expired_date) : null,
        contract_value_min: validateData.contract_value_min ? Number(validateData.contract_value_min) : null,
        contract_value_max: validateData.contract_value_max ? Number(validateData.contract_value_max) : null,
        positive_notes: validateData.positive_notes,
        negative_notes: validateData.negative_notes,
        hospital_id: hospitalId
    };

    const data = await VendorExperienceRepository.create(payload);
    await createLog(req, data);
};

exports.updateVendorHistoryService = async (validateData, req) => {
    const id_hospital = req.params.id;
    const id_vendor_experience = req.params.id_vendor_experience;

    const hospital = await prisma.hospital.findFirst({
        where: {
            id: id_hospital
        }
    })
    if (!hospital) {
        throw new HttpException("Hospital not found", 404)
    }

    const vendorHistory = await VendorExperienceRepository.findById(id_vendor_experience);
    if (!vendorHistory) {
        throw new HttpException("Vendor history not found", 404);
    }

    if (validateData.vendor_id) {
        const existVendor = await prisma.vendor.findFirst({
            where: {
                id: validateData.vendor_id
            }
        });
        if (!existVendor) {
            throw new HttpException("Vendor not found", 404)
        }
    }

    const SimrsType = ["vendor", "in house", "gratis"];
    if (validateData.simrs_type && !SimrsType.includes(validateData.simrs_type)) {
        throw new HttpException("Simrs type must be vendor, in house, or gratis", 400);
    }

    if (
        validateData.simrs_type &&
        vendorHistory.simrs_type === "vendor" &&
        vendorHistory.vendor_id !== null &&
        validateData.simrs_type !== "vendor"
    ) {
        await prisma.vendorExperience.update({
            where: {
                id: id_vendor_experience,
                deletedAt: null
            },
            data: {
                vendor_id: null
            }
        });
    }

    if (validateData.contract_start_date && validateData.contract_expired_date) {
        if (validateData.contract_start_date >= validateData.contract_expired_date) {
            throw new HttpException("Contract expired date must be after contract date", 400)
        }
    }

    if (validateData.contract_value_min && validateData.contract_value_max) {
        if (validateData.contract_value_min >= validateData.contract_value_max) {
            throw new HttpException("Contract value max must be after contract value min", 400)
        }
    }

    if (validateData.status === "active") {
        await prisma.vendorExperience.updateMany({
            where: {
                hospital_id: id_hospital,
                status: "active",
                deletedAt: null,
                NOT: { id: id_vendor_experience },
            },
            data: {
                status: "inactive",
            },
        });
    }

    const payload = {
        status: validateData.status,
        contract_start_date: validateData.contract_start_date ? new Date(validateData.contract_start_date) : vendorHistory.contract_start_date,
        contract_expired_date: validateData.contract_expired_date ? new Date(validateData.contract_expired_date) : vendorHistory.contract_expired_date,
        contract_value_min: validateData.contract_value_min ? Number(validateData.contract_value_min) : vendorHistory.contract_value_min,
        contract_value_max: validateData.contract_value_max ? Number(validateData.contract_value_max) : vendorHistory.contract_value_max,
        positive_notes: validateData.positive_notes,
        negative_notes: validateData.negative_notes,
        simrs_type: validateData.simrs_type,
        vendor_id: validateData.vendor_id,
    };

    const data = await VendorExperienceRepository.update(id_vendor_experience, payload);
    await updateLog(req, data);
};

exports.deleteVendorHistoryService = async (req) => {
    const id_hospital = req.params.id;
    const id_vendor_experience = req.params.id_vendor_experience;

    const hospital = await prisma.hospital.findFirst({
        where: {
            id: id_hospital
        }
    })
    if (!hospital) {
        throw new HttpException("Hospital not found", 404)
    }

    const vendor = await VendorExperienceRepository.findById(id_vendor_experience);
    if (!vendor) {
        throw new HttpException("Vendor history not found", 404);
    }

    const data = await VendorExperienceRepository.update(id_vendor_experience, {
        deletedAt: timeLocal.now().toDate()
    });

    await deleteLog(req, data);
};