fix: 캘린더 모달 중복 카드 문제 및 삭제 권한 개선

- monthly_worker_status 조회 시 GROUP BY로 중복 데이터 합산
- 작업보고서 삭제 권한을 그룹장 이상으로 제한 (admin, system, group_leader)
- 중복 데이터 정리를 위한 마이그레이션 SQL 추가 (009_fix_duplicate_monthly_status.sql)
- synology_deployment 버전에도 동일 수정 적용

synology_deployment/api/models/analysisModel.js

@@ -0,0 +1,115 @@
+// /models/analysisModel.js
+const { getDb } = require('../dbPool');
+
+/**
+ * 지정된 기간 동안의 작업 보고서 데이터를 집계하여 분석합니다.
+ * 이 함수는 여러 개의 SQL 쿼리를 병렬로 실행하여 효율성을 높입니다.
+ * @param {string} startDate - 시작일 (YYYY-MM-DD)
+ * @param {string} endDate - 종료일 (YYYY-MM-DD)
+ * @returns {Promise<object>} - 요약, 프로젝트별, 작업자별, 작업별 집계 데이터 및 상세 내역
+ */
+const getAnalysis = async (startDate, endDate) => {
+  try {
+    const db = await getDb();
+
+    // SQL 쿼리에서 반복적으로 사용될 WHERE 조건과 실제 투입 시간 계산 로직
+    const whereClause = `WHERE dwr.report_date BETWEEN ? AND ?`;
+    const workHoursCalc = `
+      CASE dwr.work_details
+        WHEN '연차' THEN 0 WHEN '반차' THEN 4 WHEN '반반차' THEN 6
+        WHEN '조퇴' THEN 2 WHEN '휴무' THEN 0 WHEN '유급' THEN 0
+        ELSE 8
+      END + (COALESCE(dwr.overtime_hours, 0) * 1.5)
+    `;
+
+    // 1. 요약 정보 쿼리
+    const summarySql = `
+      SELECT
+        COUNT(DISTINCT dwr.project_id) as totalProjects,
+        COUNT(DISTINCT dwr.worker_id) as totalworkers,
+        COUNT(DISTINCT dwr.task_id) as totalTasks,
+        SUM(${workHoursCalc}) as totalHours
+      FROM DailyWorkReports dwr
+      ${whereClause} AND (${workHoursCalc}) > 0
+    `;
+    
+    // 2. 프로젝트별 집계 쿼리
+    const byProjectSql = `
+      SELECT p.project_name as name, SUM(${workHoursCalc}) as hours, COUNT(DISTINCT dwr.worker_id) as participants
+      FROM DailyWorkReports dwr
+      JOIN projects p ON dwr.project_id = p.project_id
+      ${whereClause}
+      GROUP BY p.project_name
+      HAVING hours > 0
+      ORDER BY hours DESC;
+    `;
+
+    // 3. 작업자별 집계 쿼리
+    const byWorkerSql = `
+      SELECT w.worker_name as name, SUM(${workHoursCalc}) as hours, COUNT(DISTINCT dwr.project_id) as participants
+      FROM DailyWorkReports dwr
+      JOIN workers w ON dwr.worker_id = w.worker_id
+      ${whereClause}
+      GROUP BY w.worker_name
+      HAVING hours > 0
+      ORDER BY hours DESC;
+    `;
+    
+    // 4. 작업별 집계 쿼리
+    const byTaskSql = `
+      SELECT t.category as name, SUM(${workHoursCalc}) as hours, COUNT(DISTINCT dwr.worker_id) as participants
+      FROM DailyWorkReports dwr
+      JOIN Tasks t ON dwr.task_id = t.task_id
+      ${whereClause}
+      GROUP BY t.category
+      HAVING hours > 0
+      ORDER BY hours DESC;
+    `;
+
+    // 5. 상세 내역 쿼리
+    const detailsSql = `
+      SELECT 
+        dwr.report_date as date, p.project_name, w.worker_name,
+        t.category as task_category, dwr.work_details,
+        (${workHoursCalc}) as work_hours, dwr.memo
+      FROM DailyWorkReports dwr
+      JOIN projects p ON dwr.project_id = p.project_id
+      JOIN workers w ON dwr.worker_id = w.worker_id
+      JOIN Tasks t ON dwr.task_id = t.task_id
+      ${whereClause}
+      HAVING work_hours > 0
+      ORDER BY dwr.report_date DESC;
+    `;
+
+    // 모든 쿼리를 병렬로 실행
+    const [
+      [summaryResult], 
+      [byProject], 
+      [byWorker], 
+      [byTask], 
+      [details]
+    ] = await Promise.all([
+      db.query(summarySql, [startDate, endDate]),
+      db.query(byProjectSql, [startDate, endDate]),
+      db.query(byWorkerSql, [startDate, endDate]),
+      db.query(byTaskSql, [startDate, endDate]),
+      db.query(detailsSql, [startDate, endDate])
+    ]);
+
+    return {
+      summary: summaryResult[0],
+      byProject,
+      byWorker,
+      byTask,
+      details
+    };
+
+  } catch (err) {
+    console.error('[Model] 분석 데이터 조회 오류:', err);
+    throw new Error('데이터베이스에서 분석 데이터를 조회하는 중 오류가 발생했습니다.');
+  }
+};
+
+module.exports = {
+  getAnalysis
+}; 

synology_deployment/api/models/attendanceModel.js

@@ -0,0 +1,303 @@
+const { getDb } = require('../dbPool');
+
+class AttendanceModel {
+  // 일일 근태 기록 조회
+  static async getDailyAttendanceRecords(date, workerId = null) {
+    const db = await getDb();
+    let query = `
+      SELECT 
+        dar.*,
+        w.worker_name,
+        w.job_type,
+        wat.type_name as attendance_type_name,
+        wat.type_code as attendance_type_code,
+        vt.type_name as vacation_type_name,
+        vt.type_code as vacation_type_code,
+        vt.hours_deduction as vacation_hours
+      FROM daily_attendance_records dar
+      LEFT JOIN workers w ON dar.worker_id = w.worker_id
+      LEFT JOIN work_attendance_types wat ON dar.attendance_type_id = wat.id
+      LEFT JOIN vacation_types vt ON dar.vacation_type_id = vt.id
+      WHERE dar.record_date = ?
+    `;
+    
+    const params = [date];
+    
+    if (workerId) {
+      query += ' AND dar.worker_id = ?';
+      params.push(workerId);
+    }
+    
+    query += ' ORDER BY w.worker_name';
+    
+    const [rows] = await db.execute(query, params);
+    return rows;
+  }
+
+  // 근태 기록 생성 또는 업데이트
+  static async upsertAttendanceRecord(recordData) {
+    const db = await getDb();
+    
+    const {
+      record_date,
+      worker_id,
+      total_work_hours,
+      work_attendance_type_id,
+      vacation_type_id,
+      is_overtime_approved,
+      created_by
+    } = recordData;
+
+    // 기존 기록 확인
+    const [existing] = await db.execute(
+      'SELECT id FROM daily_attendance_records WHERE worker_id = ? AND record_date = ?',
+      [worker_id, record_date]
+    );
+
+    if (existing.length > 0) {
+      // 업데이트
+      const [result] = await db.execute(`
+        UPDATE daily_attendance_records 
+        SET 
+          total_work_hours = ?,
+          work_attendance_type_id = ?,
+          vacation_type_id = ?,
+          is_overtime_approved = ?,
+          updated_at = CURRENT_TIMESTAMP
+        WHERE id = ?
+      `, [
+        total_work_hours,
+        work_attendance_type_id,
+        vacation_type_id,
+        is_overtime_approved,
+        existing[0].id
+      ]);
+      
+      return { id: existing[0].id, affected: result.affectedRows };
+    } else {
+      // 생성
+      const [result] = await db.execute(`
+        INSERT INTO daily_attendance_records (
+          record_date, worker_id, total_work_hours, work_attendance_type_id,
+          vacation_type_id, is_overtime_approved, created_by
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `, [
+        record_date,
+        worker_id,
+        total_work_hours,
+        work_attendance_type_id,
+        vacation_type_id,
+        is_overtime_approved,
+        created_by
+      ]);
+      
+      return { id: result.insertId, affected: result.affectedRows };
+    }
+  }
+
+  // 작업자별 근태 현황 조회 (대시보드용)
+  static async getWorkerAttendanceStatus(date) {
+    const db = await getDb();
+    
+    // 모든 작업자와 해당 날짜의 근태 기록을 조회
+    const [rows] = await db.execute(`
+      SELECT 
+        w.worker_id,
+        w.worker_name,
+        w.job_type,
+        COALESCE(dar.total_work_hours, 0) as total_work_hours,
+        COALESCE(dar.status, 'incomplete') as status,
+        dar.is_vacation_processed,
+        dar.overtime_approved,
+        wat.type_name as attendance_type_name,
+        wat.type_code as attendance_type_code,
+        vt.type_name as vacation_type_name,
+        vt.type_code as vacation_type_code,
+        dar.notes,
+        -- 작업 건수 계산
+        (SELECT COUNT(*) FROM daily_work_reports dwr 
+         WHERE dwr.worker_id = w.worker_id AND dwr.report_date = ?) as work_count,
+        -- 오류 건수 계산
+        (SELECT COUNT(*) FROM daily_work_reports dwr 
+         WHERE dwr.worker_id = w.worker_id AND dwr.report_date = ? AND dwr.work_status_id = 2) as error_count
+      FROM workers w
+      LEFT JOIN daily_attendance_records dar ON w.worker_id = dar.worker_id AND dar.record_date = ?
+      LEFT JOIN work_attendance_types wat ON dar.attendance_type_id = wat.id
+      LEFT JOIN vacation_types vt ON dar.vacation_type_id = vt.id
+      WHERE w.is_active = TRUE
+      ORDER BY w.worker_name
+    `, [date, date, date]);
+    
+    return rows;
+  }
+
+  // 휴가 처리
+  static async processVacation(workerId, date, vacationType, createdBy) {
+    const db = await getDb();
+    
+    // 휴가 유형 정보 조회
+    const [vacationTypes] = await db.execute(
+      'SELECT * FROM vacation_types WHERE type_code = ?',
+      [vacationType]
+    );
+    
+    if (vacationTypes.length === 0) {
+      throw new Error('유효하지 않은 휴가 유형입니다.');
+    }
+    
+    const vacationTypeInfo = vacationTypes[0];
+    
+    // 현재 작업 시간 조회
+    const [workHours] = await db.execute(`
+      SELECT COALESCE(SUM(work_hours), 0) as total_hours
+      FROM daily_work_reports 
+      WHERE worker_id = ? AND report_date = ?
+    `, [workerId, date]);
+    
+    const currentHours = parseFloat(workHours[0].total_hours);
+    const vacationHours = parseFloat(vacationTypeInfo.hours_deduction);
+    const totalHours = currentHours + vacationHours;
+    
+    // 근로 유형 결정
+    let attendanceTypeCode = 'VACATION';
+    let status = 'vacation';
+    
+    if (totalHours >= 8) {
+      attendanceTypeCode = totalHours > 8 ? 'OVERTIME' : 'REGULAR';
+      status = totalHours > 8 ? 'overtime' : 'complete';
+    }
+    
+    const [attendanceTypes] = await db.execute(
+      'SELECT id FROM work_attendance_types WHERE type_code = ?',
+      [attendanceTypeCode]
+    );
+    
+    // 휴가 작업 기록 생성 (프로젝트 ID 13 = "연차/휴무", work_type_id 1 = 기본)
+    await db.execute(`
+      INSERT INTO daily_work_reports (
+        report_date, worker_id, project_id, work_type_id, work_status_id,
+        work_hours, description, created_by
+      ) VALUES (?, ?, 13, 1, 1, ?, ?, ?)
+    `, [
+      date,
+      workerId,
+      vacationHours,
+      `${vacationTypeInfo.type_name} 처리`,
+      createdBy
+    ]);
+    
+    // 근태 기록 업데이트
+    const attendanceData = {
+      record_date: date,
+      worker_id: workerId,
+      total_work_hours: totalHours,
+      work_attendance_type_id: attendanceTypes[0]?.id,
+      vacation_type_id: vacationTypeInfo.id,
+      is_overtime_approved: false,
+      created_by: createdBy
+    };
+    
+    return await this.upsertAttendanceRecord(attendanceData);
+  }
+
+  // 초과근무 승인
+  static async approveOvertime(workerId, date, approvedBy) {
+    const db = await getDb();
+    
+    const [result] = await db.execute(`
+      UPDATE daily_attendance_records 
+      SET 
+        overtime_approved = TRUE,
+        overtime_approved_by = ?,
+        overtime_approved_at = CURRENT_TIMESTAMP,
+        updated_by = ?,
+        updated_at = CURRENT_TIMESTAMP
+      WHERE worker_id = ? AND record_date = ?
+    `, [approvedBy, approvedBy, workerId, date]);
+    
+    return result.affectedRows > 0;
+  }
+
+  // 근로 유형 목록 조회
+  static async getAttendanceTypes() {
+    const db = await getDb();
+    const [rows] = await db.execute(
+      'SELECT * FROM work_attendance_types WHERE is_active = TRUE ORDER BY id'
+    );
+    return rows;
+  }
+
+  // 휴가 유형 목록 조회
+  static async getVacationTypes() {
+    const db = await getDb();
+    const [rows] = await db.execute(
+      'SELECT * FROM vacation_types WHERE is_active = TRUE ORDER BY hours_deduction DESC'
+    );
+    return rows;
+  }
+
+  // 작업자 휴가 잔여 조회
+  static async getWorkerVacationBalance(workerId, year = null) {
+    const db = await getDb();
+    const currentYear = year || new Date().getFullYear();
+    
+    const [rows] = await db.execute(`
+      SELECT * FROM worker_vacation_balance 
+      WHERE worker_id = ? AND year = ?
+    `, [workerId, currentYear]);
+    
+    if (rows.length === 0) {
+      // 기본 연차 생성 (15일)
+      await db.execute(`
+        INSERT INTO worker_vacation_balance (worker_id, year, total_annual_leave)
+        VALUES (?, ?, 15.0)
+      `, [workerId, currentYear]);
+      
+      return {
+        worker_id: workerId,
+        year: currentYear,
+        total_annual_leave: 15.0,
+        used_annual_leave: 0,
+        remaining_annual_leave: 15.0
+      };
+    }
+    
+    return rows[0];
+  }
+
+  // 월별 근태 통계
+  static async getMonthlyAttendanceStats(year, month, workerId = null) {
+    const db = await getDb();
+    
+    let query = `
+      SELECT 
+        w.worker_id,
+        w.worker_name,
+        COUNT(CASE WHEN dar.status = 'complete' THEN 1 END) as regular_days,
+        COUNT(CASE WHEN dar.status = 'overtime' THEN 1 END) as overtime_days,
+        COUNT(CASE WHEN dar.status = 'vacation' THEN 1 END) as vacation_days,
+        COUNT(CASE WHEN dar.status = 'partial' THEN 1 END) as partial_days,
+        COUNT(CASE WHEN dar.status = 'incomplete' THEN 1 END) as incomplete_days,
+        SUM(dar.total_work_hours) as total_work_hours,
+        AVG(dar.total_work_hours) as avg_work_hours
+      FROM workers w
+      LEFT JOIN daily_attendance_records dar ON w.worker_id = dar.worker_id
+        AND YEAR(dar.record_date) = ? AND MONTH(dar.record_date) = ?
+      WHERE w.is_active = TRUE
+    `;
+    
+    const params = [year, month];
+    
+    if (workerId) {
+      query += ' AND w.worker_id = ?';
+      params.push(workerId);
+    }
+    
+    query += ' GROUP BY w.worker_id, w.worker_name ORDER BY w.worker_name';
+    
+    const [rows] = await db.execute(query, params);
+    return rows;
+  }
+}
+
+module.exports = AttendanceModel;

synology_deployment/api/models/dailyIssueReportModel.js

@@ -0,0 +1,154 @@
+const { getDb } = require('../dbPool');
+
+/**
+ * 1. 여러 개의 이슈 보고서를 트랜잭션으로 생성합니다.
+ * @param {Array<object>} reports - 생성할 보고서 데이터 배열
+ * @returns {Promise<Array<number>>} - 삽입된 ID 배열
+ */
+const createMany = async (reports) => {
+  const db = await getDb();
+  const conn = await db.getConnection();
+  try {
+    await conn.beginTransaction();
+
+    const insertedIds = [];
+    const sql = `
+      INSERT INTO DailyIssueReports 
+      (date, worker_id, project_id, start_time, end_time, issue_type_id)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `;
+
+    for (const report of reports) {
+      const { date, worker_id, project_id, start_time, end_time, issue_type_id } = report;
+      const [result] = await conn.query(sql, [date, worker_id, project_id, start_time, end_time, issue_type_id]);
+      insertedIds.push(result.insertId);
+    }
+
+    await conn.commit();
+    return insertedIds;
+  } catch (err) {
+    await conn.rollback();
+    console.error('[Model] 여러 이슈 보고서 생성 중 오류:', err);
+    throw new Error('데이터베이스에 이슈 보고서를 생성하는 중 오류가 발생했습니다.');
+  } finally {
+    conn.release();
+  }
+};
+
+/**
+ * 2. 특정 날짜의 전체 이슈 목록 조회 (Promise 기반)
+ */
+const getAllByDate = async (date) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT 
+        d.id, d.date, w.worker_name, p.project_name, d.start_time, d.end_time,
+        t.category, t.subcategory, d.description
+       FROM DailyIssueReports d
+       LEFT JOIN workers w ON d.worker_id = w.worker_id
+       LEFT JOIN projects p ON d.project_id = p.project_id
+       LEFT JOIN IssueTypes t ON d.issue_type_id = t.issue_type_id
+       WHERE d.date = ?
+       ORDER BY d.start_time ASC`,
+      [date]
+    );
+    return rows;
+  } catch (err) {
+    console.error(`[Model] ${date} 이슈 목록 조회 오류:`, err);
+    throw new Error('데이터베이스에서 이슈 목록을 조회하는 중 오류가 발생했습니다.');
+  }
+};
+
+/**
+ * 3. 단일 조회 (선택사항: 컨트롤러에서 사용 중)
+ */
+const getById = async (id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(`SELECT * FROM DailyIssueReports WHERE id = ?`, [id]);
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+/**
+ * 4. 수정
+ */
+const update = async (id, data, callback) => {
+  try {
+    const db = await getDb();
+
+    const fields = [];
+    const values = [];
+
+    for (const key in data) {
+      fields.push(`${key} = ?`);
+      values.push(data[key]);
+    }
+
+    values.push(id); // 마지막에 id
+
+    const [result] = await db.query(
+      `UPDATE DailyIssueReports SET ${fields.join(', ')} WHERE id = ?`,
+      values
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+/**
+ * 5. 삭제 (Promise 기반)
+ */
+const remove = async (id) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(`DELETE FROM DailyIssueReports WHERE id = ?`, [id]);
+    return result.affectedRows;
+  } catch (err) {
+    console.error(`[Model] 이슈(id: ${id}) 삭제 오류:`, err);
+    throw new Error('데이터베이스에서 이슈를 삭제하는 중 오류가 발생했습니다.');
+  }
+};
+
+// V1 함수들은 점진적으로 제거 예정
+const create = async (report, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      date,
+      worker_id,
+      project_id,
+      start_time,
+      end_time,
+      issue_type_id,
+      description = null // 선택값 처리
+    } = report;
+
+    const [result] = await db.query(
+      `INSERT INTO DailyIssueReports 
+       (date, worker_id, project_id, start_time, end_time, issue_type_id, description)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [date, worker_id, project_id, start_time, end_time, issue_type_id, description]
+    );
+
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+
+module.exports = {
+  createMany, // 신규
+  getAllByDate,
+  remove,
+  // 레거시 호환성을 위해 V1 함수들 임시 유지
+  create: (report, callback) => createMany([report]).then(ids => callback(null, ids[0])).catch(err => callback(err)),
+  getById,
+  update,
+};

synology_deployment/api/models/issueTypeModel.js

@@ -0,0 +1,58 @@
+const { getDb } = require('../dbPool');
+
+// CREATE
+const create = async (type, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `INSERT INTO IssueTypes (category, subcategory) VALUES (?, ?)`,
+      [type.category, type.subcategory]
+    );
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// READ ALL
+const getAll = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(`SELECT * FROM IssueTypes ORDER BY category, subcategory`);
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// UPDATE
+const update = async (id, type, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `UPDATE IssueTypes SET category = ?, subcategory = ? WHERE id = ?`,
+      [type.category, type.subcategory, id]
+    );
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// DELETE
+const remove = async (id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(`DELETE FROM IssueTypes WHERE id = ?`, [id]);
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+module.exports = {
+  create,
+  getAll,
+  update,
+  remove
+};

synology_deployment/api/models/monthlyStatusModel.js

@@ -0,0 +1,172 @@
+// models/monthlyStatusModel.js
+// 월별 작업자 상태 집계 모델
+
+const { getDb } = require('../dbPool');
+
+class MonthlyStatusModel {
+  // 월별 일자별 요약 조회 (캘린더용)
+  static async getMonthlySummary(year, month) {
+    const db = await getDb();
+    
+    try {
+      const [rows] = await db.execute(`
+        SELECT 
+          date,
+          total_workers,
+          working_workers,
+          incomplete_workers,
+          partial_workers,
+          complete_workers,
+          overtime_workers,
+          vacation_workers,
+          error_workers,
+          overtime_warning_workers,
+          total_work_hours,
+          total_work_count,
+          total_error_count,
+          has_issues,
+          has_errors,
+          has_overtime_warning,
+          last_updated
+        FROM monthly_summary 
+        WHERE year = ? AND month = ?
+        ORDER BY date ASC
+      `, [year, month]);
+      
+      return rows;
+    } catch (error) {
+      console.error('월별 요약 조회 오류:', error);
+      throw error;
+    }
+  }
+  
+  // 특정 날짜의 작업자별 상태 조회 (모달용)
+  static async getDailyWorkerStatus(date) {
+    const db = await getDb();
+    
+    try {
+      // 중복 방지: worker_id와 date로 그룹화하고 최신 데이터만 조회
+      const [rows] = await db.execute(`
+        SELECT 
+          mws.worker_id,
+          w.worker_name,
+          w.job_type,
+          MAX(mws.year) as year,
+          MAX(mws.month) as month,
+          mws.date,
+          SUM(mws.total_work_hours) as total_work_hours,
+          SUM(mws.actual_work_hours) as actual_work_hours,
+          SUM(mws.vacation_hours) as vacation_hours,
+          SUM(mws.total_work_count) as total_work_count,
+          SUM(mws.regular_work_count) as regular_work_count,
+          SUM(mws.error_work_count) as error_work_count,
+          MAX(mws.work_status) as work_status,
+          MAX(mws.has_vacation) as has_vacation,
+          MAX(mws.has_error) as has_error,
+          MAX(mws.has_issues) as has_issues,
+          MAX(mws.last_updated) as last_updated
+        FROM monthly_worker_status mws
+        JOIN workers w ON mws.worker_id = w.worker_id
+        WHERE mws.date = ?
+        GROUP BY mws.worker_id, mws.date, w.worker_name, w.job_type
+        ORDER BY w.worker_name ASC
+      `, [date]);
+      
+      return rows;
+    } catch (error) {
+      console.error('일별 작업자 상태 조회 오류:', error);
+      throw error;
+    }
+  }
+  
+  // 월별 집계 데이터 강제 재계산 (관리용)
+  static async recalculateMonth(year, month) {
+    const db = await getDb();
+    
+    try {
+      // 해당 월의 모든 날짜와 작업자 조합을 찾아서 재계산
+      const [workDates] = await db.execute(`
+        SELECT DISTINCT report_date, worker_id
+        FROM daily_work_reports 
+        WHERE YEAR(report_date) = ? AND MONTH(report_date) = ?
+      `, [year, month]);
+      
+      let updatedCount = 0;
+      
+      for (const { report_date, worker_id } of workDates) {
+        await db.execute('CALL UpdateMonthlyWorkerStatus(?, ?)', [report_date, worker_id]);
+        updatedCount++;
+      }
+      
+      console.log(`✅ ${year}년 ${month}월 집계 재계산 완료: ${updatedCount}건`);
+      return { success: true, updatedCount };
+      
+    } catch (error) {
+      console.error('월별 집계 재계산 오류:', error);
+      throw error;
+    }
+  }
+  
+  // 특정 날짜 집계 강제 업데이트
+  static async updateDateSummary(date, workerId = null) {
+    const db = await getDb();
+    
+    try {
+      if (workerId) {
+        // 특정 작업자만 업데이트
+        await db.execute('CALL UpdateMonthlyWorkerStatus(?, ?)', [date, workerId]);
+      } else {
+        // 해당 날짜의 모든 작업자 업데이트
+        const [workers] = await db.execute(`
+          SELECT DISTINCT worker_id
+          FROM daily_work_reports 
+          WHERE report_date = ?
+        `, [date]);
+        
+        for (const { worker_id } of workers) {
+          await db.execute('CALL UpdateMonthlyWorkerStatus(?, ?)', [date, worker_id]);
+        }
+      }
+      
+      return { success: true };
+    } catch (error) {
+      console.error('날짜별 집계 업데이트 오류:', error);
+      throw error;
+    }
+  }
+  
+  // 집계 테이블 상태 확인
+  static async getStatusInfo() {
+    const db = await getDb();
+    
+    try {
+      const [summaryCount] = await db.execute(`
+        SELECT 
+          COUNT(*) as total_days,
+          MIN(date) as earliest_date,
+          MAX(date) as latest_date,
+          MAX(last_updated) as last_update
+        FROM monthly_summary
+      `);
+      
+      const [workerStatusCount] = await db.execute(`
+        SELECT 
+          COUNT(*) as total_records,
+          COUNT(DISTINCT worker_id) as unique_workers,
+          COUNT(DISTINCT date) as unique_dates,
+          MAX(last_updated) as last_update
+        FROM monthly_worker_status
+      `);
+      
+      return {
+        summary: summaryCount[0],
+        workerStatus: workerStatusCount[0]
+      };
+    } catch (error) {
+      console.error('집계 테이블 상태 확인 오류:', error);
+      throw error;
+    }
+  }
+}
+
+module.exports = MonthlyStatusModel;

synology_deployment/api/models/projectModel.js

@@ -0,0 +1,120 @@
+const { getDb } = require('../dbPool');
+
+const create = async (project, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      job_no, project_name,
+      contract_date, due_date,
+      delivery_method, site, pm,
+      is_active = true,
+      project_status = 'active',
+      completed_date = null
+    } = project;
+  
+    const [result] = await db.query(
+      `INSERT INTO projects
+       (job_no, project_name, contract_date, due_date, delivery_method, site, pm, is_active, project_status, completed_date)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [job_no, project_name, contract_date, due_date, delivery_method, site, pm, is_active, project_status, completed_date]
+    );
+
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const getAll = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM projects ORDER BY project_id DESC`
+    );
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// 활성 프로젝트만 조회 (작업보고서용)
+const getActiveProjects = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM projects 
+       WHERE is_active = TRUE 
+       ORDER BY project_name ASC`
+    );
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const getById = async (project_id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM projects WHERE project_id = ?`,
+      [project_id]
+    );
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const update = async (project, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      project_id, job_no, project_name,
+      contract_date, due_date,
+      delivery_method, site, pm,
+      is_active, project_status, completed_date
+    } = project;
+
+    const [result] = await db.query(
+      `UPDATE projects
+       SET job_no         = ?,
+           project_name   = ?,
+           contract_date  = ?,
+           due_date       = ?,
+           delivery_method= ?,
+           site           = ?,
+           pm             = ?,
+           is_active      = ?,
+           project_status = ?,
+           completed_date = ?
+       WHERE project_id = ?`,
+      [job_no, project_name, contract_date, due_date, delivery_method, site, pm, is_active, project_status, completed_date, project_id]
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(new Error(err.message || String(err)));
+  }
+};
+
+const remove = async (project_id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `DELETE FROM projects WHERE project_id = ?`,
+      [project_id]
+    );
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+module.exports = {
+  create,
+  getAll,
+  getActiveProjects,
+  getById,
+  update,
+  remove
+};

synology_deployment/api/models/toolsModel.js

@@ -0,0 +1,89 @@
+const { getDb } = require('../dbPool');
+
+// 1. 전체 도구 조회
+const getAll = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query('SELECT * FROM Tools');
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// 2. 단일 도구 조회
+const getById = async (id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query('SELECT * FROM Tools WHERE id = ?', [id]);
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// 3. 도구 생성
+const create = async (tool, callback) => {
+  try {
+    const db = await getDb();
+    const { name, location, stock, status, factory_id, map_x, map_y, map_zone, map_note } = tool;
+
+    const [result] = await db.query(
+      `INSERT INTO Tools
+       (name, location, stock, status, factory_id, map_x, map_y, map_zone, map_note)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [name, location, stock, status, factory_id, map_x, map_y, map_zone, map_note]
+    );
+
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// 4. 도구 수정
+const update = async (id, tool, callback) => {
+  try {
+    const db = await getDb();
+    const { name, location, stock, status, factory_id, map_x, map_y, map_zone, map_note } = tool;
+
+    const [result] = await db.query(
+      `UPDATE Tools
+       SET name       = ?,
+           location   = ?,
+           stock      = ?,
+           status     = ?,
+           factory_id = ?,
+           map_x      = ?,
+           map_y      = ?,
+           map_zone   = ?,
+           map_note   = ?
+       WHERE id = ?`,
+      [name, location, stock, status, factory_id, map_x, map_y, map_zone, map_note, id]
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(new Error(err.message || String(err)));
+  }
+};
+
+// 5. 도구 삭제
+const remove = async (id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query('DELETE FROM Tools WHERE id = ?', [id]);
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// ✅ export 정리
+module.exports = {
+  getAll,
+  getById,
+  create,
+  update,
+  remove
+};

synology_deployment/api/models/uploadModel.js

@@ -0,0 +1,45 @@
+const { getDb } = require('../dbPool');
+
+// 1. 문서 업로드
+const create = async (doc, callback) => {
+  try {
+    const db = await getDb();
+    const sql = `
+      INSERT INTO uploaded_documents
+        (title, tags, description, original_name, stored_name, file_path, file_type, file_size, submitted_by)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `;
+    const values = [
+      doc.title,
+      doc.tags,
+      doc.description,
+      doc.original_name,
+      doc.stored_name,
+      doc.file_path,
+      doc.file_type,
+      doc.file_size,
+      doc.submitted_by
+    ];
+    const [result] = await db.query(sql, values);
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(new Error(err.message || String(err)));
+  }
+};
+
+// 2. 전체 문서 목록 조회
+const getAll = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(`SELECT * FROM uploaded_documents ORDER BY created_at DESC`);
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// ✅ 내보내기
+module.exports = {
+  create,
+  getAll
+};

synology_deployment/api/models/userModel.js

@@ -0,0 +1,75 @@
+const { getDb } = require('../dbPool');
+
+// 사용자 조회
+const findByUsername = async (username) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      'SELECT * FROM users WHERE username = ?', [username]
+    );
+    return rows[0];
+  } catch (err) {
+    console.error('DB 오류 - 사용자 조회 실패:', err);
+    throw err;
+  }
+};
+
+/**
+ * 로그인 실패 횟수를 1 증가시킵니다.
+ * @param {number} userId - 사용자 ID
+ */
+const incrementFailedLoginAttempts = async (userId) => {
+    try {
+        const db = await getDb();
+        await db.execute(
+            'UPDATE users SET failed_login_attempts = failed_login_attempts + 1 WHERE user_id = ?',
+            [userId]
+        );
+    } catch (err) {
+        console.error('DB 오류 - 로그인 실패 횟수 증가 실패:', err);
+        throw err;
+    }
+};
+
+/**
+ * 특정 사용자의 계정을 잠급니다.
+ * @param {number} userId - 사용자 ID
+ */
+const lockUserAccount = async (userId) => {
+    try {
+        const db = await getDb();
+        await db.execute(
+            'UPDATE users SET locked_until = DATE_ADD(NOW(), INTERVAL 15 MINUTE) WHERE user_id = ?',
+            [userId]
+        );
+    } catch (err) {
+        console.error('DB 오류 - 계정 잠금 실패:', err);
+        throw err;
+    }
+};
+
+/**
+ * 로그인 성공 시, 마지막 로그인 시간을 업데이트하고 실패 횟수와 잠금 상태를 초기화합니다.
+ * @param {number} userId - 사용자 ID
+ */
+const resetLoginAttempts = async (userId) => {
+    try {
+        const db = await getDb();
+        await db.execute(
+            'UPDATE users SET last_login_at = NOW(), failed_login_attempts = 0, locked_until = NULL WHERE user_id = ?',
+            [userId]
+        );
+    } catch (err) {
+        console.error('DB 오류 - 로그인 상태 초기화 실패:', err);
+        throw err;
+    }
+};
+
+
+// 명확한 내보내기
+module.exports = {
+  findByUsername,
+  incrementFailedLoginAttempts,
+  lockUserAccount,
+  resetLoginAttempts
+};

synology_deployment/api/models/workReportModel.js

@@ -0,0 +1,223 @@
+const { getDb } = require('../dbPool');
+
+/**
+ * 1. 여러 건 등록 (트랜잭션 사용)
+ */
+const createBatch = async (reports, callback) => {
+  const db = await getDb();
+  const conn = await db.getConnection();
+
+  try {
+    await conn.beginTransaction();
+
+    const sql = `
+      INSERT INTO WorkReports
+        (\`date\`, worker_id, project_id, task_id, overtime_hours, work_details, memo)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `;
+
+    for (const rpt of reports) {
+      const params = [
+        rpt.date,
+        rpt.worker_id,
+        rpt.project_id,
+        rpt.task_id || null,
+        rpt.overtime_hours || null,
+        rpt.work_details || null,
+        rpt.memo || null
+      ];
+      await conn.query(sql, params);
+    }
+
+    await conn.commit();
+    callback(null);
+  } catch (err) {
+    await conn.rollback();
+    callback(err);
+  } finally {
+    conn.release();
+  }
+};
+
+/**
+ * 2. 단일 등록
+ */
+const create = async (report, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      date, worker_id, project_id,
+      task_id, overtime_hours,
+      work_details, memo
+    } = report;
+
+    const [result] = await db.query(
+      `INSERT INTO WorkReports
+       (\`date\`, worker_id, project_id, task_id, overtime_hours, work_details, memo)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [
+        date,
+        worker_id,
+        project_id,
+        task_id || null,
+        overtime_hours || null,
+        work_details || null,
+        memo || null
+      ]
+    );
+
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+ /**
+  * 3. 날짜별 조회
+  */
+ const getAllByDate = async (date, callback) => {
+   try {
+     const db = await getDb();
+     const sql = `
+       SELECT 
+         wr.worker_id,               -- 이 줄을 추가했습니다
+         wr.id,
+         wr.\`date\`,
+         w.worker_name,
+         p.project_name,
+         CONCAT(t.category, ':', t.subcategory) AS task_name,
+         wr.overtime_hours,
+         wr.work_details,
+         wr.memo
+       FROM WorkReports wr
+       LEFT JOIN workers w  ON wr.worker_id  = w.worker_id
+       LEFT JOIN projects p ON wr.project_id = p.project_id
+       LEFT JOIN Tasks t    ON wr.task_id    = t.task_id
+       WHERE wr.\`date\` = ?
+       ORDER BY w.worker_name ASC
+     `;
+     const [rows] = await db.query(sql, [date]);
+     callback(null, rows);
+   } catch (err) {
+     callback(err);
+   }
+ };
+
+/**
+ * 4. 기간 조회
+ */
+const getByRange = async (start, end, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM WorkReports
+       WHERE \`date\` BETWEEN ? AND ?
+       ORDER BY \`date\` ASC`,
+      [start, end]
+    );
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+/**
+ * 5. ID로 조회
+ */
+const getById = async (id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM WorkReports WHERE id = ?`,
+      [id]
+    );
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+/**
+ * 6. 수정
+ */
+const update = async (id, report, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      date, worker_id, project_id,
+      task_id, overtime_hours,
+      work_details, memo
+    } = report;
+
+    const [result] = await db.query(
+      `UPDATE WorkReports
+       SET \`date\`         = ?,
+           worker_id       = ?,
+           project_id      = ?,
+           task_id         = ?,
+           overtime_hours  = ?,
+           work_details    = ?,
+           memo            = ?,
+           updated_at      = CURRENT_TIMESTAMP
+       WHERE id = ?`,
+      [
+        date,
+        worker_id,
+        project_id,
+        task_id || null,
+        overtime_hours || null,
+        work_details || null,
+        memo || null,
+        id
+      ]
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+/**
+ * 7. 삭제
+ */
+const remove = async (id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `DELETE FROM WorkReports WHERE id = ?`,
+      [id]
+    );
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(new Error(err.message || String(err)));
+  }
+};
+
+/**
+ * 8. 중복 확인
+ */
+const existsByDateAndWorker = async (date, worker_id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT 1 FROM WorkReports WHERE \`date\` = ? AND worker_id = ? LIMIT 1`,
+      [date, worker_id]
+    );
+    callback(null, rows.length > 0);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// ✅ 내보내기
+module.exports = {
+  create,
+  createBatch,
+  getAllByDate,
+  getByRange,
+  getById,
+  update,
+  remove,
+  existsByDateAndWorker
+};

synology_deployment/api/models/workerModel.js

@@ -0,0 +1,137 @@
+const { getDb } = require('../dbPool');
+
+// 1. 작업자 생성
+const create = async (worker, callback) => {
+  try {
+    const db = await getDb();
+    const { 
+      worker_name, 
+      job_type = 'worker', 
+      phone_number = null,
+      email = null,
+      hire_date = null,
+      department = null,
+      notes = null,
+      status = 'active'
+    } = worker;
+
+    const [result] = await db.query(
+      `INSERT INTO workers 
+       (worker_name, job_type, phone_number, email, hire_date, department, notes, status)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [worker_name, job_type, phone_number, email, hire_date, department, notes, status]
+    );
+
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// 2. 전체 조회
+const getAll = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(`SELECT * FROM workers ORDER BY worker_id DESC`);
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// 3. 단일 조회
+const getById = async (worker_id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(`SELECT * FROM workers WHERE worker_id = ?`, [worker_id]);
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// 4. 작업자 수정
+const update = async (worker, callback) => {
+  try {
+    const db = await getDb();
+    const { worker_id, worker_name, join_date, job_type, salary, annual_leave, status } = worker;
+
+    const [result] = await db.query(
+      `UPDATE workers
+       SET worker_name   = ?,
+           join_date     = ?,
+           job_type      = ?,
+           salary        = ?,
+           annual_leave  = ?,
+           status        = ?
+       WHERE worker_id = ?`,
+      [worker_name, join_date, job_type, salary, annual_leave, status, worker_id]
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+   callback(new Error(err.message || String(err)));
+  }
+};
+
+// 5. 삭제 (외래키 제약조건 처리)
+const remove = async (worker_id, callback) => {
+  const db = await getDb();
+  const conn = await db.getConnection();
+  
+  try {
+    await conn.beginTransaction();
+    
+    console.log(`🗑️ 작업자 삭제 시작: worker_id=${worker_id}`);
+    
+    // 안전한 삭제: 각 테이블을 개별적으로 처리하고 오류가 발생해도 계속 진행
+    const tables = [
+      { name: 'users', query: 'UPDATE users SET worker_id = NULL WHERE worker_id = ?', action: '업데이트' },
+      { name: 'Users', query: 'UPDATE Users SET worker_id = NULL WHERE worker_id = ?', action: '업데이트' },
+      { name: 'daily_issue_reports', query: 'DELETE FROM daily_issue_reports WHERE worker_id = ?', action: '삭제' },
+      { name: 'DailyIssueReports', query: 'DELETE FROM DailyIssueReports WHERE worker_id = ?', action: '삭제' },
+      { name: 'work_reports', query: 'DELETE FROM work_reports WHERE worker_id = ?', action: '삭제' },
+      { name: 'WorkReports', query: 'DELETE FROM WorkReports WHERE worker_id = ?', action: '삭제' },
+      { name: 'daily_work_reports', query: 'DELETE FROM daily_work_reports WHERE worker_id = ?', action: '삭제' },
+      { name: 'monthly_worker_status', query: 'DELETE FROM monthly_worker_status WHERE worker_id = ?', action: '삭제' },
+      { name: 'worker_groups', query: 'DELETE FROM worker_groups WHERE worker_id = ?', action: '삭제' }
+    ];
+    
+    for (const table of tables) {
+      try {
+        const [result] = await conn.query(table.query, [worker_id]);
+        if (result.affectedRows > 0) {
+          console.log(`✅ ${table.name} 테이블 ${table.action}: ${result.affectedRows}건`);
+        }
+      } catch (tableError) {
+        console.log(`⚠️ ${table.name} 테이블 ${table.action} 실패 (무시): ${tableError.message}`);
+      }
+    }
+    
+    // 마지막으로 작업자 삭제
+    const [result] = await conn.query(
+      `DELETE FROM workers WHERE worker_id = ?`,
+      [worker_id]
+    );
+    console.log(`✅ 작업자 삭제 완료: ${result.affectedRows}건`);
+    
+    await conn.commit();
+    callback(null, result.affectedRows);
+    
+  } catch (err) {
+    await conn.rollback();
+    console.error(`❌ 작업자 삭제 오류 (worker_id: ${worker_id}):`, err);
+    callback(new Error(`작업자 삭제 중 오류가 발생했습니다: ${err.message}`));
+  } finally {
+    conn.release();
+  }
+};
+
+// ✅ 모듈 내보내기 (정상 구조)
+module.exports = {
+  create,
+  getAll,
+  getById,
+  update,
+  remove
+};