TK-FB-Project/api.hyungi.net/models/tbmModel.js

// models/tbmModel.js - TBM 시스템 모델
const { getDb } = require('../dbPool');

const TbmModel = {
  // ==================== TBM 세션 관련 ====================

  /**
   * TBM 세션 생성
   */
  createSession: async (sessionData, callback) => {
    try {
      const db = await getDb();
      const sql = `
        INSERT INTO tbm_sessions
        (session_date, leader_id, project_id, work_type_id, task_id, work_location, created_by)
        VALUES (?, ?, ?, ?, ?, ?, ?)
      `;

      const values = [
        sessionData.session_date,
        sessionData.leader_id,
        sessionData.project_id || null,
        sessionData.work_type_id || null,
        sessionData.task_id || null,
        sessionData.work_location || null,
        sessionData.created_by
      ];

      const [result] = await db.query(sql, values);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 특정 날짜의 TBM 세션 조회
   */
  getSessionsByDate: async (date, callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT
          s.*,
          w.worker_name as leader_name,
          w.job_type as leader_job_type,
          u.username as created_by_username,
          u.name as created_by_name,
          COUNT(DISTINCT ta.worker_id) as team_member_count,
          -- 첫 번째 팀원의 작업 정보 가져오기
          first_ta.project_id,
          first_ta.work_type_id,
          first_ta.task_id,
          first_ta.workplace_id,
          first_p.project_name,
          first_wt.name as work_type_name,
          first_t.task_name,
          first_wp.workplace_name as work_location
        FROM tbm_sessions s
        LEFT JOIN workers w ON s.leader_id = w.worker_id
        LEFT JOIN users u ON s.created_by = u.user_id
        LEFT JOIN tbm_team_assignments ta ON s.session_id = ta.session_id
        -- 첫 번째 팀원 정보 (가장 먼저 등록된 작업)
        LEFT JOIN (
          SELECT * FROM tbm_team_assignments
          WHERE (session_id, assignment_id) IN (
            SELECT session_id, MIN(assignment_id)
            FROM tbm_team_assignments
            GROUP BY session_id
          )
        ) first_ta ON s.session_id = first_ta.session_id
        LEFT JOIN projects first_p ON first_ta.project_id = first_p.project_id
        LEFT JOIN work_types first_wt ON first_ta.work_type_id = first_wt.id
        LEFT JOIN tasks first_t ON first_ta.task_id = first_t.task_id
        LEFT JOIN workplaces first_wp ON first_ta.workplace_id = first_wp.workplace_id
        WHERE s.session_date = ?
        GROUP BY s.session_id
        ORDER BY s.session_id DESC
      `;

      const [rows] = await db.query(sql, [date]);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * TBM 세션 상세 조회
   */
  getSessionById: async (sessionId, callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT
          s.*,
          w.worker_name as leader_name,
          w.job_type as leader_job_type,
          w.phone_number as leader_phone,
          p.project_name,
          p.job_no,
          p.site,
          wt.name as work_type_name,
          wt.category as work_type_category,
          t.task_name,
          t.description as task_description,
          u.username as created_by_username,
          u.name as created_by_name
        FROM tbm_sessions s
        LEFT JOIN workers w ON s.leader_id = w.worker_id
        LEFT JOIN projects p ON s.project_id = p.project_id
        LEFT JOIN work_types wt ON s.work_type_id = wt.id
        LEFT JOIN tasks t ON s.task_id = t.task_id
        LEFT JOIN users u ON s.created_by = u.user_id
        WHERE s.session_id = ?
      `;

      const [rows] = await db.query(sql, [sessionId]);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * TBM 세션 수정
   */
  updateSession: async (sessionId, sessionData, callback) => {
    try {
      const db = await getDb();
      const sql = `
        UPDATE tbm_sessions
        SET
          project_id = ?,
          work_location = ?,
          status = ?,
          updated_at = NOW()
        WHERE session_id = ?
      `;

      const values = [
        sessionData.project_id,
        sessionData.work_location,
        sessionData.status,
        sessionId
      ];

      const [result] = await db.query(sql, values);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * TBM 세션 완료 처리
   */
  completeSession: async (sessionId, endTime, callback) => {
    try {
      const db = await getDb();
      const sql = `
        UPDATE tbm_sessions
        SET
          status = 'completed',
          end_time = ?,
          updated_at = NOW()
        WHERE session_id = ?
      `;

      const [result] = await db.query(sql, [endTime, sessionId]);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  // ==================== 팀 구성 관련 ====================

  /**
   * 팀원 추가 (작업자별 상세 정보 포함)
   */
  addTeamMember: async (assignmentData, callback) => {
    try {
      const db = await getDb();
      const sql = `
        INSERT INTO tbm_team_assignments
        (session_id, worker_id, assigned_role, work_detail, is_present, absence_reason,
         project_id, work_type_id, task_id, workplace_category_id, workplace_id)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON DUPLICATE KEY UPDATE
          assigned_role = VALUES(assigned_role),
          work_detail = VALUES(work_detail),
          is_present = VALUES(is_present),
          absence_reason = VALUES(absence_reason),
          project_id = VALUES(project_id),
          work_type_id = VALUES(work_type_id),
          task_id = VALUES(task_id),
          workplace_category_id = VALUES(workplace_category_id),
          workplace_id = VALUES(workplace_id)
      `;

      const values = [
        assignmentData.session_id,
        assignmentData.worker_id,
        assignmentData.assigned_role,
        assignmentData.work_detail,
        assignmentData.is_present !== undefined ? assignmentData.is_present : true,
        assignmentData.absence_reason,
        assignmentData.project_id || null,
        assignmentData.work_type_id || null,
        assignmentData.task_id || null,
        assignmentData.workplace_category_id || null,
        assignmentData.workplace_id || null
      ];

      const [result] = await db.query(sql, values);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 팀 구성 일괄 추가 (작업자별 상세 정보 포함)
   */
  addTeamMembers: async (sessionId, members, callback) => {
    try {
      if (!members || members.length === 0) {
        return callback(null, { affectedRows: 0 });
      }

      const db = await getDb();
      const values = members.map(m => [
        sessionId,
        m.worker_id,
        m.assigned_role || null,
        m.work_detail || null,
        m.is_present !== undefined ? m.is_present : true,
        m.absence_reason || null,
        m.project_id || null,
        m.work_type_id || null,
        m.task_id || null,
        m.workplace_category_id || null,
        m.workplace_id || null
      ]);

      const sql = `
        INSERT INTO tbm_team_assignments
        (session_id, worker_id, assigned_role, work_detail, is_present, absence_reason,
         project_id, work_type_id, task_id, workplace_category_id, workplace_id)
        VALUES ?
      `;

      const [result] = await db.query(sql, [values]);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * TBM 세션의 팀 구성 조회 (작업자별 상세 정보 포함)
   */
  getTeamMembers: async (sessionId, callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT
          ta.*,
          w.worker_name,
          w.job_type,
          w.phone_number,
          w.department,
          p.project_name,
          wt.name as work_type_name,
          t.task_name,
          wc.category_name AS workplace_category_name,
          wp.workplace_name
        FROM tbm_team_assignments ta
        INNER JOIN workers w ON ta.worker_id = w.worker_id
        LEFT JOIN projects p ON ta.project_id = p.project_id
        LEFT JOIN work_types wt ON ta.work_type_id = wt.id
        LEFT JOIN tasks t ON ta.task_id = t.task_id
        LEFT JOIN workplace_categories wc ON ta.workplace_category_id = wc.category_id
        LEFT JOIN workplaces wp ON ta.workplace_id = wp.workplace_id
        WHERE ta.session_id = ?
        ORDER BY ta.assigned_at DESC
      `;

      const [rows] = await db.query(sql, [sessionId]);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 팀원 제거
   */
  removeTeamMember: async (sessionId, workerId, callback) => {
    try {
      const db = await getDb();
      const sql = `
        DELETE FROM tbm_team_assignments
        WHERE session_id = ? AND worker_id = ?
      `;

      const [result] = await db.query(sql, [sessionId, workerId]);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 세션의 모든 팀원 삭제
   */
  clearAllTeamMembers: async (sessionId, callback) => {
    try {
      const db = await getDb();
      const sql = `
        DELETE FROM tbm_team_assignments
        WHERE session_id = ?
      `;

      const [result] = await db.query(sql, [sessionId]);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  // ==================== 안전 체크리스트 관련 ====================

  /**
   * 모든 안전 체크 항목 조회
   */
  getAllSafetyChecks: async (callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT *
        FROM tbm_safety_checks
        WHERE is_active = 1
        ORDER BY check_category, display_order
      `;

      const [rows] = await db.query(sql);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 카테고리별 안전 체크 항목 조회
   */
  getSafetyChecksByCategory: async (category, callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT *
        FROM tbm_safety_checks
        WHERE check_category = ? AND is_active = 1
        ORDER BY display_order
      `;

      const [rows] = await db.query(sql, [category]);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * TBM 세션의 안전 체크 기록 조회
   */
  getSafetyRecords: async (sessionId, callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT
          sr.*,
          sc.check_category,
          sc.check_item,
          sc.description,
          sc.is_required,
          u.username as checked_by_username,
          u.name as checked_by_name
        FROM tbm_safety_records sr
        INNER JOIN tbm_safety_checks sc ON sr.check_id = sc.check_id
        LEFT JOIN users u ON sr.checked_by = u.user_id
        WHERE sr.session_id = ?
        ORDER BY sc.check_category, sc.display_order
      `;

      const [rows] = await db.query(sql, [sessionId]);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 안전 체크 기록 저장/업데이트
   */
  saveSafetyRecord: async (recordData, callback) => {
    try {
      const db = await getDb();
      const sql = `
        INSERT INTO tbm_safety_records
        (session_id, check_id, is_checked, notes, checked_by, checked_at)
        VALUES (?, ?, ?, ?, ?, NOW())
        ON DUPLICATE KEY UPDATE
          is_checked = VALUES(is_checked),
          notes = VALUES(notes),
          checked_by = VALUES(checked_by),
          checked_at = NOW()
      `;

      const values = [
        recordData.session_id,
        recordData.check_id,
        recordData.is_checked,
        recordData.notes,
        recordData.checked_by
      ];

      const [result] = await db.query(sql, values);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 안전 체크 일괄 저장
   */
  saveSafetyRecords: async (sessionId, records, checkedBy, callback) => {
    try {
      if (!records || records.length === 0) {
        return callback(null, { affectedRows: 0 });
      }

      const db = await getDb();
      const values = records.map(r => [
        sessionId,
        r.check_id,
        r.is_checked,
        r.notes || null,
        checkedBy
      ]);

      const sql = `
        INSERT INTO tbm_safety_records
        (session_id, check_id, is_checked, notes, checked_by, checked_at)
        VALUES ?
        ON DUPLICATE KEY UPDATE
          is_checked = VALUES(is_checked),
          notes = VALUES(notes),
          checked_by = VALUES(checked_by),
          checked_at = NOW()
      `;

      const [result] = await db.query(sql, [values]);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  // ==================== 작업 인계 관련 ====================

  /**
   * 작업 인계 생성
   */
  createHandover: async (handoverData, callback) => {
    try {
      const db = await getDb();
      const sql = `
        INSERT INTO team_handovers
        (session_id, from_leader_id, to_leader_id, handover_date, handover_time,
         reason, handover_notes, worker_ids)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
      `;

      const values = [
        handoverData.session_id,
        handoverData.from_leader_id,
        handoverData.to_leader_id,
        handoverData.handover_date,
        handoverData.handover_time,
        handoverData.reason,
        handoverData.handover_notes,
        JSON.stringify(handoverData.worker_ids || [])
      ];

      const [result] = await db.query(sql, values);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 작업 인계 확인
   */
  confirmHandover: async (handoverId, confirmedBy, callback) => {
    try {
      const db = await getDb();
      const sql = `
        UPDATE team_handovers
        SET
          is_confirmed = 1,
          confirmed_at = NOW(),
          confirmed_by = ?
        WHERE handover_id = ?
      `;

      const [result] = await db.query(sql, [confirmedBy, handoverId]);
      callback(null, result);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 특정 날짜의 작업 인계 목록 조회
   */
  getHandoversByDate: async (date, callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT
          h.*,
          w1.worker_name as from_leader_name,
          w2.worker_name as to_leader_name,
          u.username as confirmed_by_username,
          u.name as confirmed_by_name
        FROM team_handovers h
        INNER JOIN workers w1 ON h.from_leader_id = w1.worker_id
        INNER JOIN workers w2 ON h.to_leader_id = w2.worker_id
        LEFT JOIN users u ON h.confirmed_by = u.user_id
        WHERE h.handover_date = ?
        ORDER BY h.handover_time DESC
      `;

      const [rows] = await db.query(sql, [date]);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 인수자가 받은 미확인 인계 건 조회
   */
  getPendingHandovers: async (toLeaderId, callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT
          h.*,
          w1.worker_name as from_leader_name,
          w1.phone_number as from_leader_phone,
          s.work_location
        FROM team_handovers h
        INNER JOIN workers w1 ON h.from_leader_id = w1.worker_id
        LEFT JOIN tbm_sessions s ON h.session_id = s.session_id
        WHERE h.to_leader_id = ? AND h.is_confirmed = 0
        ORDER BY h.handover_date DESC, h.handover_time DESC
      `;

      const [rows] = await db.query(sql, [toLeaderId]);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  // ==================== 통계 및 리포트 ====================

  /**
   * 특정 기간의 TBM 통계
   */
  getTbmStatistics: async (startDate, endDate, callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT
          DATE(session_date) as date,
          COUNT(DISTINCT session_id) as session_count,
          COUNT(DISTINCT leader_id) as leader_count,
          SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed_count
        FROM tbm_sessions
        WHERE session_date BETWEEN ? AND ?
        GROUP BY DATE(session_date)
        ORDER BY date DESC
      `;

      const [rows] = await db.query(sql, [startDate, endDate]);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 리더별 TBM 진행 현황
   */
  getLeaderStatistics: async (startDate, endDate, callback) => {
    try {
      const db = await getDb();
      const sql = `
        SELECT
          s.leader_id,
          w.worker_name as leader_name,
          COUNT(DISTINCT s.session_id) as total_sessions,
          SUM(CASE WHEN s.status = 'completed' THEN 1 ELSE 0 END) as completed_sessions,
          COUNT(DISTINCT ta.worker_id) as total_team_members
        FROM tbm_sessions s
        INNER JOIN workers w ON s.leader_id = w.worker_id
        LEFT JOIN tbm_team_assignments ta ON s.session_id = ta.session_id
        WHERE s.session_date BETWEEN ? AND ?
        GROUP BY s.leader_id
        ORDER BY total_sessions DESC
      `;

      const [rows] = await db.query(sql, [startDate, endDate]);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  },

  /**
   * 작업보고서가 작성되지 않은 TBM 세션의 팀 배정 조회
   * @param {number|null} userId - 조회할 사용자 ID (null이면 모든 TBM 조회 - 관리자용)
   */
  getIncompleteWorkReports: async (userId, callback) => {
    try {
      const db = await getDb();

      // WHERE 조건 동적 생성
      let whereClause = `
        WHERE dwr.id IS NULL
          AND s.status = 'draft'
      `;
      const params = [];

      // userId가 있으면 created_by 조건 추가 (일반 사용자)
      if (userId !== null && userId !== undefined) {
        whereClause = `
          WHERE s.created_by = ?
            AND dwr.id IS NULL
            AND s.status = 'draft'
        `;
        params.push(userId);
      }

      const sql = `
        SELECT
          ta.assignment_id,
          ta.session_id,
          ta.worker_id,
          ta.project_id,
          ta.work_type_id,
          ta.task_id,
          ta.workplace_category_id,
          ta.workplace_id,
          s.session_date,
          s.status as session_status,
          s.created_by,
          w.worker_name,
          w.job_type,
          p.project_name,
          wt.name as work_type_name,
          t.task_name,
          wp.workplace_name,
          wc.category_name,
          creator.name as created_by_name
        FROM tbm_team_assignments ta
        INNER JOIN tbm_sessions s ON ta.session_id = s.session_id
        INNER JOIN workers w ON ta.worker_id = w.worker_id
        LEFT JOIN users creator ON s.created_by = creator.user_id
        LEFT JOIN projects p ON ta.project_id = p.project_id
        LEFT JOIN work_types wt ON ta.work_type_id = wt.id
        LEFT JOIN tasks t ON ta.task_id = t.task_id
        LEFT JOIN workplaces wp ON ta.workplace_id = wp.workplace_id
        LEFT JOIN workplace_categories wc ON ta.workplace_category_id = wc.category_id
        LEFT JOIN daily_work_reports dwr ON ta.assignment_id = dwr.tbm_assignment_id
        ${whereClause}
        ORDER BY s.session_date DESC, ta.assignment_id ASC
      `;

      const [rows] = await db.query(sql, params);
      callback(null, rows);
    } catch (err) {
      callback(err);
    }
  }
};

module.exports = TbmModel;