erp-construccion-backend/dist/modules/quality/controllers/inspection.controller.js

"use strict";
/**
 * InspectionController - REST API for quality inspections
 *
 * Endpoints para gestión de inspecciones de calidad.
 *
 * @module Quality
 * @routes /api/inspections
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.createInspectionController = createInspectionController;
const express_1 = require("express");
const inspection_service_1 = require("../services/inspection.service");
const inspection_entity_1 = require("../entities/inspection.entity");
const inspection_result_entity_1 = require("../entities/inspection-result.entity");
const non_conformity_entity_1 = require("../entities/non-conformity.entity");
const checklist_entity_1 = require("../entities/checklist.entity");
const auth_middleware_1 = require("../../auth/middleware/auth.middleware");
const auth_service_1 = require("../../auth/services/auth.service");
const user_entity_1 = require("../../core/entities/user.entity");
const tenant_entity_1 = require("../../core/entities/tenant.entity");
const refresh_token_entity_1 = require("../../auth/entities/refresh-token.entity");
function createInspectionController(dataSource) {
    const router = (0, express_1.Router)();
    // Repositories
    const inspectionRepo = dataSource.getRepository(inspection_entity_1.Inspection);
    const resultRepo = dataSource.getRepository(inspection_result_entity_1.InspectionResult);
    const ncRepo = dataSource.getRepository(non_conformity_entity_1.NonConformity);
    const checklistRepo = dataSource.getRepository(checklist_entity_1.Checklist);
    const userRepository = dataSource.getRepository(user_entity_1.User);
    const tenantRepository = dataSource.getRepository(tenant_entity_1.Tenant);
    const refreshTokenRepository = dataSource.getRepository(refresh_token_entity_1.RefreshToken);
    // Services
    const service = new inspection_service_1.InspectionService(inspectionRepo, resultRepo, ncRepo, checklistRepo);
    const authService = new auth_service_1.AuthService(userRepository, tenantRepository, refreshTokenRepository);
    const authMiddleware = new auth_middleware_1.AuthMiddleware(authService, dataSource);
    // Helper for service context
    const getContext = (req) => {
        if (!req.tenantId) {
            throw new Error('Tenant ID is required');
        }
        return {
            tenantId: req.tenantId,
            userId: req.user?.sub,
        };
    };
    /**
     * GET /api/inspections
     * List inspections with filters
     */
    router.get('/', authMiddleware.authenticate, async (req, res, next) => {
        try {
            const tenantId = req.tenantId;
            if (!tenantId) {
                res.status(400).json({ error: 'Bad Request', message: 'Tenant ID required' });
                return;
            }
            const filters = {};
            if (req.query.checklistId)
                filters.checklistId = req.query.checklistId;
            if (req.query.loteId)
                filters.loteId = req.query.loteId;
            if (req.query.inspectorId)
                filters.inspectorId = req.query.inspectorId;
            if (req.query.status)
                filters.status = req.query.status;
            if (req.query.dateFrom)
                filters.dateFrom = new Date(req.query.dateFrom);
            if (req.query.dateTo)
                filters.dateTo = new Date(req.query.dateTo);
            const page = parseInt(req.query.page) || 1;
            const limit = Math.min(parseInt(req.query.limit) || 20, 100);
            const result = await service.findWithFilters(getContext(req), filters, page, limit);
            res.status(200).json({ success: true, data: result.data, pagination: result.meta });
        }
        catch (error) {
            next(error);
        }
    });
    /**
     * GET /api/inspections/:id
     * Get inspection with details
     */
    router.get('/:id', authMiddleware.authenticate, async (req, res, next) => {
        try {
            const tenantId = req.tenantId;
            if (!tenantId) {
                res.status(400).json({ error: 'Bad Request', message: 'Tenant ID required' });
                return;
            }
            const inspection = await service.findWithDetails(getContext(req), req.params.id);
            if (!inspection) {
                res.status(404).json({ error: 'Not Found', message: 'Inspection not found' });
                return;
            }
            res.status(200).json({ success: true, data: inspection });
        }
        catch (error) {
            next(error);
        }
    });
    /**
     * POST /api/inspections
     * Create new inspection
     */
    router.post('/', authMiddleware.authenticate, authMiddleware.authorize('admin', 'quality', 'resident'), async (req, res, next) => {
        try {
            const tenantId = req.tenantId;
            if (!tenantId) {
                res.status(400).json({ error: 'Bad Request', message: 'Tenant ID required' });
                return;
            }
            const inspection = await service.create(getContext(req), {
                checklistId: req.body.checklistId,
                loteId: req.body.loteId,
                inspectionDate: new Date(req.body.inspectionDate),
                inspectorId: req.body.inspectorId,
                notes: req.body.notes,
            });
            res.status(201).json({ success: true, data: inspection });
        }
        catch (error) {
            next(error);
        }
    });
    /**
     * POST /api/inspections/:id/start
     * Start inspection
     */
    router.post('/:id/start', authMiddleware.authenticate, authMiddleware.authorize('admin', 'quality', 'resident'), async (req, res, next) => {
        try {
            const tenantId = req.tenantId;
            if (!tenantId) {
                res.status(400).json({ error: 'Bad Request', message: 'Tenant ID required' });
                return;
            }
            const inspection = await service.startInspection(getContext(req), req.params.id);
            if (!inspection) {
                res.status(404).json({ error: 'Not Found', message: 'Inspection not found' });
                return;
            }
            res.status(200).json({ success: true, data: inspection });
        }
        catch (error) {
            next(error);
        }
    });
    /**
     * POST /api/inspections/:id/results
     * Record inspection result
     */
    router.post('/:id/results', authMiddleware.authenticate, authMiddleware.authorize('admin', 'quality', 'resident'), async (req, res, next) => {
        try {
            const tenantId = req.tenantId;
            if (!tenantId) {
                res.status(400).json({ error: 'Bad Request', message: 'Tenant ID required' });
                return;
            }
            const result = await service.recordResult(getContext(req), req.params.id, {
                checklistItemId: req.body.checklistItemId,
                result: req.body.result,
                observations: req.body.observations,
                photoUrl: req.body.photoUrl,
            });
            res.status(201).json({ success: true, data: result });
        }
        catch (error) {
            next(error);
        }
    });
    /**
     * POST /api/inspections/:id/complete
     * Complete inspection
     */
    router.post('/:id/complete', authMiddleware.authenticate, authMiddleware.authorize('admin', 'quality', 'resident'), async (req, res, next) => {
        try {
            const tenantId = req.tenantId;
            if (!tenantId) {
                res.status(400).json({ error: 'Bad Request', message: 'Tenant ID required' });
                return;
            }
            const inspection = await service.completeInspection(getContext(req), req.params.id);
            if (!inspection) {
                res.status(404).json({ error: 'Not Found', message: 'Inspection not found' });
                return;
            }
            res.status(200).json({ success: true, data: inspection });
        }
        catch (error) {
            next(error);
        }
    });
    /**
     * POST /api/inspections/:id/approve
     * Approve inspection
     */
    router.post('/:id/approve', authMiddleware.authenticate, authMiddleware.authorize('admin', 'quality'), async (req, res, next) => {
        try {
            const tenantId = req.tenantId;
            if (!tenantId) {
                res.status(400).json({ error: 'Bad Request', message: 'Tenant ID required' });
                return;
            }
            const inspection = await service.approveInspection(getContext(req), req.params.id);
            if (!inspection) {
                res.status(404).json({ error: 'Not Found', message: 'Inspection not found' });
                return;
            }
            res.status(200).json({ success: true, data: inspection });
        }
        catch (error) {
            next(error);
        }
    });
    /**
     * POST /api/inspections/:id/reject
     * Reject inspection
     */
    router.post('/:id/reject', authMiddleware.authenticate, authMiddleware.authorize('admin', 'quality'), async (req, res, next) => {
        try {
            const tenantId = req.tenantId;
            if (!tenantId) {
                res.status(400).json({ error: 'Bad Request', message: 'Tenant ID required' });
                return;
            }
            const inspection = await service.rejectInspection(getContext(req), req.params.id, req.body.reason);
            if (!inspection) {
                res.status(404).json({ error: 'Not Found', message: 'Inspection not found' });
                return;
            }
            res.status(200).json({ success: true, data: inspection });
        }
        catch (error) {
            next(error);
        }
    });
    return router;
}
//# sourceMappingURL=inspection.controller.js.map