tk-factory-services/tksafety/api/controllers/visitRequestController.js

const visitRequestModel = require('../models/visitRequestModel');
const notify = require('../shared/utils/notifyHelper');

// ==================== 출입 신청 관리 ====================

exports.createVisitRequest = async (req, res) => {
  try {
    const requester_id = req.user.user_id;
    const requestData = { requester_id, ...req.body };
    const isInternal = requestData.request_type === 'internal';

    // 내부 출입: visitor_name 필수, 외부: visitor_company 필수
    if (isInternal) {
      const requiredFields = ['visitor_name', 'category_id', 'workplace_id', 'visit_date', 'visit_time', 'purpose_id'];
      for (const field of requiredFields) {
        if (!requestData[field]) {
          return res.status(400).json({ success: false, message: `${field}는 필수 입력 항목입니다.` });
        }
      }
      requestData.visitor_count = 1;
      requestData.visitor_company = requestData.visitor_company || '내부';
    } else {
      const requiredFields = ['visitor_company', 'category_id', 'workplace_id', 'visit_date', 'visit_time', 'purpose_id'];
      for (const field of requiredFields) {
        if (!requestData[field]) {
          return res.status(400).json({ success: false, message: `${field}는 필수 입력 항목입니다.` });
        }
      }
    }

    const requestId = await visitRequestModel.createVisitRequest(requestData);
    res.status(201).json({
      success: true,
      message: isInternal ? '내부 출입 신고가 완료되었습니다.' : '출입 신청이 성공적으로 생성되었습니다.',
      data: { request_id: requestId }
    });
  } catch (err) {
    console.error('출입 신청 생성 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 생성 중 오류가 발생했습니다.' });
  }
};

exports.getAllVisitRequests = async (req, res) => {
  try {
    const filters = {
      status: req.query.status,
      visit_date: req.query.visit_date,
      start_date: req.query.start_date,
      end_date: req.query.end_date,
      requester_id: req.query.requester_id,
      category_id: req.query.category_id,
      request_type: req.query.request_type
    };

    const requests = await visitRequestModel.getAllVisitRequests(filters);
    res.json({ success: true, data: requests });
  } catch (err) {
    console.error('출입 신청 목록 조회 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 목록 조회 중 오류가 발생했습니다.' });
  }
};

exports.getVisitRequestById = async (req, res) => {
  try {
    const request = await visitRequestModel.getVisitRequestById(req.params.id);
    if (!request) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }
    res.json({ success: true, data: request });
  } catch (err) {
    console.error('출입 신청 조회 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 조회 중 오류가 발생했습니다.' });
  }
};

exports.updateVisitRequest = async (req, res) => {
  try {
    const result = await visitRequestModel.updateVisitRequest(req.params.id, req.body);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '출입 신청이 수정되었습니다.' });
  } catch (err) {
    console.error('출입 신청 수정 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 수정 중 오류가 발생했습니다.' });
  }
};

exports.deleteVisitRequest = async (req, res) => {
  try {
    const result = await visitRequestModel.deleteVisitRequest(req.params.id);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '출입 신청이 삭제되었습니다.' });
  } catch (err) {
    console.error('출입 신청 삭제 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 삭제 중 오류가 발생했습니다.' });
  }
};

exports.approveVisitRequest = async (req, res) => {
  try {
    const result = await visitRequestModel.approveVisitRequest(req.params.id, req.user.user_id);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }

    // 알림: 신청자에게 승인 알림
    const request = await visitRequestModel.getVisitRequestById(req.params.id).catch(() => null);
    if (request) {
      notify.send({
        type: 'safety',
        title: '출입 신청 승인',
        message: `${request.visitor_company || ''} 출입 신청이 승인되었습니다.`,
        link_url: '/visit-request.html',
        reference_type: 'visit_requests',
        reference_id: parseInt(req.params.id),
        created_by: req.user.user_id
      });
    }

    res.json({ success: true, message: '출입 신청이 승인되었습니다.' });
  } catch (err) {
    console.error('출입 신청 승인 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 승인 중 오류가 발생했습니다.' });
  }
};

exports.rejectVisitRequest = async (req, res) => {
  try {
    const rejectionData = {
      approved_by: req.user.user_id,
      rejection_reason: req.body.rejection_reason || '사유 없음'
    };
    const result = await visitRequestModel.rejectVisitRequest(req.params.id, rejectionData);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '출입 신청을 찾을 수 없습니다.' });
    }

    // 알림: 신청자에게 반려 알림
    const request = await visitRequestModel.getVisitRequestById(req.params.id).catch(() => null);
    if (request) {
      notify.send({
        type: 'safety',
        title: '출입 신청 반려',
        message: `${request.visitor_company || ''} 출입 신청이 반려되었습니다. 사유: ${rejectionData.rejection_reason}`,
        link_url: '/visit-request.html',
        reference_type: 'visit_requests',
        reference_id: parseInt(req.params.id),
        created_by: req.user.user_id
      });
    }

    res.json({ success: true, message: '출입 신청이 반려되었습니다.' });
  } catch (err) {
    console.error('출입 신청 반려 오류:', err);
    res.status(500).json({ success: false, message: '출입 신청 반려 중 오류가 발생했습니다.' });
  }
};

// ==================== 방문 목적 관리 ====================

exports.getAllVisitPurposes = async (req, res) => {
  try {
    const purposes = await visitRequestModel.getAllVisitPurposes();
    res.json({ success: true, data: purposes });
  } catch (err) {
    console.error('방문 목적 조회 오류:', err);
    res.status(500).json({ success: false, message: '방문 목적 조회 중 오류가 발생했습니다.' });
  }
};

exports.getActiveVisitPurposes = async (req, res) => {
  try {
    const purposes = await visitRequestModel.getActiveVisitPurposes();
    res.json({ success: true, data: purposes });
  } catch (err) {
    console.error('활성 방문 목적 조회 오류:', err);
    res.status(500).json({ success: false, message: '활성 방문 목적 조회 중 오류가 발생했습니다.' });
  }
};

exports.createVisitPurpose = async (req, res) => {
  try {
    if (!req.body.purpose_name) {
      return res.status(400).json({ success: false, message: 'purpose_name은 필수 입력 항목입니다.' });
    }
    const purposeId = await visitRequestModel.createVisitPurpose(req.body);
    res.status(201).json({
      success: true,
      message: '방문 목적이 추가되었습니다.',
      data: { purpose_id: purposeId }
    });
  } catch (err) {
    console.error('방문 목적 추가 오류:', err);
    res.status(500).json({ success: false, message: '방문 목적 추가 중 오류가 발생했습니다.' });
  }
};

exports.updateVisitPurpose = async (req, res) => {
  try {
    const result = await visitRequestModel.updateVisitPurpose(req.params.id, req.body);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '방문 목적을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '방문 목적이 수정되었습니다.' });
  } catch (err) {
    console.error('방문 목적 수정 오류:', err);
    res.status(500).json({ success: false, message: '방문 목적 수정 중 오류가 발생했습니다.' });
  }
};

exports.deleteVisitPurpose = async (req, res) => {
  try {
    const result = await visitRequestModel.deleteVisitPurpose(req.params.id);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '방문 목적을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '방문 목적이 삭제되었습니다.' });
  } catch (err) {
    console.error('방문 목적 삭제 오류:', err);
    res.status(500).json({ success: false, message: '방문 목적 삭제 중 오류가 발생했습니다.' });
  }
};

// ==================== 안전교육 기록 관리 ====================

exports.createTrainingRecord = async (req, res) => {
  try {
    const trainingData = { trainer_id: req.user.user_id, ...req.body };

    const requiredFields = ['request_id', 'training_date', 'training_start_time'];
    for (const field of requiredFields) {
      if (!trainingData[field]) {
        return res.status(400).json({ success: false, message: `${field}는 필수 입력 항목입니다.` });
      }
    }

    const trainingId = await visitRequestModel.createTrainingRecord(trainingData);

    // 안전교육 기록 생성 후 출입 신청 상태를 training_completed로 변경
    try {
      await visitRequestModel.updateVisitRequestStatus(trainingData.request_id, 'training_completed');
    } catch (statusErr) {
      console.error('출입 신청 상태 업데이트 오류:', statusErr);
    }

    res.status(201).json({
      success: true,
      message: '안전교육 기록이 생성되었습니다.',
      data: { training_id: trainingId }
    });
  } catch (err) {
    console.error('안전교육 기록 생성 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 기록 생성 중 오류가 발생했습니다.' });
  }
};

exports.getTrainingRecordByRequestId = async (req, res) => {
  try {
    const record = await visitRequestModel.getTrainingRecordByRequestId(req.params.requestId);
    res.json({ success: true, data: record || null });
  } catch (err) {
    console.error('안전교육 기록 조회 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 기록 조회 중 오류가 발생했습니다.' });
  }
};

exports.updateTrainingRecord = async (req, res) => {
  try {
    const result = await visitRequestModel.updateTrainingRecord(req.params.id, req.body);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '안전교육 기록을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '안전교육 기록이 수정되었습니다.' });
  } catch (err) {
    console.error('안전교육 기록 수정 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 기록 수정 중 오류가 발생했습니다.' });
  }
};

exports.deleteTrainingRecord = async (req, res) => {
  try {
    const result = await visitRequestModel.deleteTrainingRecord(req.params.id);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '안전교육 기록을 찾을 수 없습니다.' });
    }
    res.json({ success: true, message: '안전교육 기록이 삭제되었습니다.' });
  } catch (err) {
    console.error('안전교육 기록 삭제 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 기록 삭제 중 오류가 발생했습니다.' });
  }
};

exports.completeTraining = async (req, res) => {
  try {
    const trainingId = req.params.id;
    const signatureData = req.body.signature_data;

    if (!signatureData) {
      return res.status(400).json({ success: false, message: '서명 데이터가 필요합니다.' });
    }

    const result = await visitRequestModel.completeTraining(trainingId, signatureData);
    if (result.affectedRows === 0) {
      return res.status(404).json({ success: false, message: '안전교육 기록을 찾을 수 없습니다.' });
    }

    // 교육 완료 후 출입 신청 상태 변경
    try {
      const record = await visitRequestModel.getTrainingRecordByRequestId(trainingId);
      if (record) {
        await visitRequestModel.updateVisitRequestStatus(record.request_id, 'training_completed');
      }
    } catch (statusErr) {
      console.error('출입 신청 상태 업데이트 오류:', statusErr);
    }

    // 알림: 안전교육 완료
    notify.send({
      type: 'safety',
      title: '안전교육 완료',
      message: '안전교육이 완료되었습니다.',
      link_url: '/training.html',
      reference_type: 'training_records',
      reference_id: parseInt(trainingId),
      created_by: req.user.user_id
    });

    res.json({ success: true, message: '안전교육이 완료되었습니다.' });
  } catch (err) {
    console.error('안전교육 완료 처리 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 완료 처리 중 오류가 발생했습니다.' });
  }
};

exports.getTrainingRecords = async (req, res) => {
  try {
    const filters = {
      training_date: req.query.training_date,
      start_date: req.query.start_date,
      end_date: req.query.end_date,
      trainer_id: req.query.trainer_id
    };
    const records = await visitRequestModel.getTrainingRecords(filters);
    res.json({ success: true, data: records });
  } catch (err) {
    console.error('안전교육 기록 목록 조회 오류:', err);
    res.status(500).json({ success: false, message: '안전교육 기록 목록 조회 중 오류가 발생했습니다.' });
  }
};

// ==================== 작업장 분류/작업장 조회 ====================

exports.getAllCategories = async (req, res) => {
  try {
    const categories = await visitRequestModel.getAllCategories();
    res.json({ success: true, data: categories });
  } catch (err) {
    console.error('작업장 분류 조회 오류:', err);
    res.status(500).json({ success: false, message: '작업장 분류 조회 중 오류가 발생했습니다.' });
  }
};

exports.getWorkplaces = async (req, res) => {
  try {
    const workplaces = await visitRequestModel.getWorkplacesByCategory(req.query.category_id);
    res.json({ success: true, data: workplaces });
  } catch (err) {
    console.error('작업장 조회 오류:', err);
    res.status(500).json({ success: false, message: '작업장 조회 중 오류가 발생했습니다.' });
  }
};

// ==================== 체크인/체크아웃 ====================

exports.checkIn = async (req, res) => {
  try {
    const result = await visitRequestModel.checkIn(req.params.id, req.user.user_id);
    if (result.error) {
      return res.status(result.status).json({ success: false, message: result.error });
    }

    // 알림: 방문자 체크인
    const request = await visitRequestModel.getVisitRequestById(req.params.id).catch(() => null);
    if (request) {
      notify.send({
        type: 'safety',
        title: '방문자 체크인',
        message: `${request.visitor_company || ''} ${request.visitor_name || ''} 체크인`,
        link_url: '/visit-management.html',
        reference_type: 'visit_requests',
        reference_id: parseInt(req.params.id),
        created_by: req.user.user_id
      });
    }

    res.json({ success: true, message: '체크인되었습니다.' });
  } catch (err) {
    console.error('체크인 오류:', err);
    res.status(500).json({ success: false, message: '체크인 중 오류가 발생했습니다.' });
  }
};

exports.checkOut = async (req, res) => {
  try {
    const result = await visitRequestModel.checkOut(req.params.id, req.user.user_id);
    if (result.error) {
      return res.status(result.status).json({ success: false, message: result.error });
    }
    res.json({ success: true, message: '체크아웃되었습니다.' });
  } catch (err) {
    console.error('체크아웃 오류:', err);
    res.status(500).json({ success: false, message: '체크아웃 중 오류가 발생했습니다.' });
  }
};

// ==================== 통합 대시보드 ====================

exports.getEntryDashboard = async (req, res) => {
  try {
    const date = req.query.date || new Date().toISOString().substring(0, 10);
    const data = await visitRequestModel.getEntryDashboard(date);
    res.json({ success: true, data, date });
  } catch (err) {
    console.error('출입 대시보드 조회 오류:', err);
    res.status(500).json({ success: false, message: '출입 대시보드 조회 중 오류가 발생했습니다.' });
  }
};

exports.getEntryStats = async (req, res) => {
  try {
    const date = req.query.date || new Date().toISOString().substring(0, 10);
    const stats = await visitRequestModel.getEntryStats(date);
    res.json({ success: true, data: stats, date });
  } catch (err) {
    console.error('출입 통계 조회 오류:', err);
    res.status(500).json({ success: false, message: '출입 통계 조회 중 오류가 발생했습니다.' });
  }
};

// ==================== 부서 목록 ====================

exports.getDepartments = async (req, res) => {
  try {
    const departments = await visitRequestModel.getAllDepartments();
    res.json({ success: true, data: departments });
  } catch (err) {
    console.error('부서 목록 조회 오류:', err);
    res.status(500).json({ success: false, message: '부서 목록 조회 중 오류가 발생했습니다.' });
  }
};