feat: 초기 프로젝트 설정 및 룰.md 파일 추가

api.hyungi.net/models/WorkAnalysis.js

@@ -0,0 +1,430 @@
+// models/WorkAnalysis.js - 향상된 버전
+
+class WorkAnalysis {
+    constructor(db) {
+        this.db = db;
+    }
+
+    // 기본 통계 조회
+    async getBasicStats(startDate, endDate) {
+        const query = `
+            SELECT 
+                COALESCE(SUM(work_hours), 0) as total_hours,
+                COUNT(*) as total_reports,
+                COUNT(DISTINCT project_id) as active_projects,
+                COUNT(DISTINCT worker_id) as active_workers,
+                SUM(CASE WHEN work_status_id = 2 THEN 1 ELSE 0 END) as error_reports,
+                ROUND(AVG(work_hours), 2) as avg_hours_per_report
+            FROM daily_work_reports 
+            WHERE report_date BETWEEN ? AND ?
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [startDate, endDate]);
+            const stats = results[0];
+            
+            const errorRate = stats.total_reports > 0 
+                ? (stats.error_reports / stats.total_reports) * 100 
+                : 0;
+
+            return {
+                totalHours: parseFloat(stats.total_hours) || 0,
+                totalReports: parseInt(stats.total_reports) || 0,
+                activeProjects: parseInt(stats.active_projects) || 0,
+                activeWorkers: parseInt(stats.active_workers) || 0,
+                errorRate: parseFloat(errorRate.toFixed(2)) || 0,
+                avgHoursPerReport: parseFloat(stats.avg_hours_per_report) || 0
+            };
+        } catch (error) {
+            throw new Error(`기본 통계 조회 실패: ${error.message}`);
+        }
+    }
+
+    // 일별 작업시간 추이
+    async getDailyTrend(startDate, endDate) {
+        const query = `
+            SELECT 
+                report_date as date,
+                SUM(work_hours) as hours,
+                COUNT(*) as reports,
+                COUNT(DISTINCT worker_id) as workers,
+                SUM(CASE WHEN work_status_id = 2 THEN 1 ELSE 0 END) as errors
+            FROM daily_work_reports 
+            WHERE report_date BETWEEN ? AND ?
+            GROUP BY report_date
+            ORDER BY report_date
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [startDate, endDate]);
+            return results.map(row => ({
+                date: row.date,
+                hours: parseFloat(row.hours) || 0,
+                reports: parseInt(row.reports) || 0,
+                workers: parseInt(row.workers) || 0,
+                errors: parseInt(row.errors) || 0
+            }));
+        } catch (error) {
+            throw new Error(`일별 추이 조회 실패: ${error.message}`);
+        }
+    }
+
+    // 작업자별 통계
+    async getWorkerStats(startDate, endDate) {
+        const query = `
+            SELECT 
+                dwr.worker_id,
+                w.worker_name,
+                SUM(dwr.work_hours) as totalHours,
+                COUNT(*) as totalReports,
+                ROUND(AVG(dwr.work_hours), 2) as avgHours,
+                COUNT(DISTINCT dwr.project_id) as projectCount,
+                SUM(CASE WHEN dwr.work_status_id = 2 THEN 1 ELSE 0 END) as errorCount,
+                COUNT(DISTINCT dwr.report_date) as workingDays
+            FROM daily_work_reports dwr
+            LEFT JOIN Workers w ON dwr.worker_id = w.worker_id
+            WHERE dwr.report_date BETWEEN ? AND ?
+            GROUP BY dwr.worker_id, w.worker_name
+            ORDER BY totalHours DESC
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [startDate, endDate]);
+            return results.map(row => ({
+                worker_id: row.worker_id,
+                worker_name: row.worker_name || `작업자 ${row.worker_id}`,
+                totalHours: parseFloat(row.totalHours) || 0,
+                totalReports: parseInt(row.totalReports) || 0,
+                avgHours: parseFloat(row.avgHours) || 0,
+                projectCount: parseInt(row.projectCount) || 0,
+                errorCount: parseInt(row.errorCount) || 0,
+                workingDays: parseInt(row.workingDays) || 0,
+                errorRate: row.totalReports > 0 ? parseFloat(((row.errorCount / row.totalReports) * 100).toFixed(2)) : 0
+            }));
+        } catch (error) {
+            throw new Error(`작업자별 통계 조회 실패: ${error.message}`);
+        }
+    }
+
+    // 프로젝트별 통계
+    async getProjectStats(startDate, endDate) {
+        const query = `
+            SELECT 
+                dwr.project_id,
+                p.project_name,
+                SUM(dwr.work_hours) as totalHours,
+                COUNT(*) as totalReports,
+                COUNT(DISTINCT dwr.worker_id) as workerCount,
+                ROUND(AVG(dwr.work_hours), 2) as avgHours,
+                SUM(CASE WHEN dwr.work_status_id = 2 THEN 1 ELSE 0 END) as errorCount,
+                COUNT(DISTINCT dwr.report_date) as activeDays
+            FROM daily_work_reports dwr
+            LEFT JOIN Projects p ON dwr.project_id = p.project_id
+            WHERE dwr.report_date BETWEEN ? AND ?
+            GROUP BY dwr.project_id, p.project_name
+            ORDER BY totalHours DESC
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [startDate, endDate]);
+            return results.map(row => ({
+                project_id: row.project_id,
+                project_name: row.project_name || `프로젝트 ${row.project_id}`,
+                totalHours: parseFloat(row.totalHours) || 0,
+                totalReports: parseInt(row.totalReports) || 0,
+                workerCount: parseInt(row.workerCount) || 0,
+                avgHours: parseFloat(row.avgHours) || 0,
+                errorCount: parseInt(row.errorCount) || 0,
+                activeDays: parseInt(row.activeDays) || 0,
+                errorRate: row.totalReports > 0 ? parseFloat(((row.errorCount / row.totalReports) * 100).toFixed(2)) : 0
+            }));
+        } catch (error) {
+            throw new Error(`프로젝트별 통계 조회 실패: ${error.message}`);
+        }
+    }
+
+    // 작업유형별 통계
+    async getWorkTypeStats(startDate, endDate) {
+        const query = `
+            SELECT 
+                dwr.work_type_id,
+                wt.name as work_type_name,
+                SUM(dwr.work_hours) as totalHours,
+                COUNT(*) as totalReports,
+                ROUND(AVG(dwr.work_hours), 2) as avgHours,
+                COUNT(DISTINCT dwr.worker_id) as workerCount,
+                SUM(CASE WHEN dwr.work_status_id = 2 THEN 1 ELSE 0 END) as errorCount,
+                COUNT(DISTINCT dwr.project_id) as projectCount
+            FROM daily_work_reports dwr
+            LEFT JOIN work_types wt ON dwr.work_type_id = wt.id
+            WHERE dwr.report_date BETWEEN ? AND ?
+            GROUP BY dwr.work_type_id, wt.name
+            ORDER BY totalHours DESC
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [startDate, endDate]);
+            return results.map(row => ({
+                work_type_id: row.work_type_id,
+                work_type_name: row.work_type_name || `작업유형 ${row.work_type_id}`,
+                totalHours: parseFloat(row.totalHours) || 0,
+                totalReports: parseInt(row.totalReports) || 0,
+                avgHours: parseFloat(row.avgHours) || 0,
+                workerCount: parseInt(row.workerCount) || 0,
+                errorCount: parseInt(row.errorCount) || 0,
+                projectCount: parseInt(row.projectCount) || 0,
+                errorRate: row.totalReports > 0 ? parseFloat(((row.errorCount / row.totalReports) * 100).toFixed(2)) : 0
+            }));
+        } catch (error) {
+            throw new Error(`작업유형별 통계 조회 실패: ${error.message}`);
+        }
+    }
+
+    // 최근 작업 현황
+    async getRecentWork(startDate, endDate, limit = 50) {
+        const query = `
+            SELECT 
+                dwr.id,
+                dwr.report_date,
+                dwr.worker_id,
+                w.worker_name,
+                dwr.project_id,
+                p.project_name,
+                dwr.work_type_id,
+                wt.name as work_type_name,
+                dwr.work_status_id,
+                wst.name as work_status_name,
+                dwr.error_type_id,
+                et.name as error_type_name,
+                dwr.work_hours,
+                dwr.created_by,
+                u.name as created_by_name,
+                dwr.created_at
+            FROM daily_work_reports dwr
+            LEFT JOIN Workers w ON dwr.worker_id = w.worker_id
+            LEFT JOIN Projects p ON dwr.project_id = p.project_id
+            LEFT JOIN work_types wt ON dwr.work_type_id = wt.id
+            LEFT JOIN work_status_types wst ON dwr.work_status_id = wst.id
+            LEFT JOIN error_types et ON dwr.error_type_id = et.id
+            LEFT JOIN Users u ON dwr.created_by = u.user_id
+            WHERE dwr.report_date BETWEEN ? AND ?
+            ORDER BY dwr.created_at DESC
+            LIMIT ?
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [startDate, endDate, parseInt(limit)]);
+            return results.map(row => ({
+                id: row.id,
+                report_date: row.report_date,
+                worker_id: row.worker_id,
+                worker_name: row.worker_name || `작업자 ${row.worker_id}`,
+                project_id: row.project_id,
+                project_name: row.project_name || `프로젝트 ${row.project_id}`,
+                work_type_id: row.work_type_id,
+                work_type_name: row.work_type_name || `작업유형 ${row.work_type_id}`,
+                work_status_id: row.work_status_id,
+                work_status_name: row.work_status_name || '정상',
+                error_type_id: row.error_type_id,
+                error_type_name: row.error_type_name || null,
+                work_hours: parseFloat(row.work_hours) || 0,
+                created_by: row.created_by,
+                created_by_name: row.created_by_name || '미지정',
+                created_at: row.created_at
+            }));
+        } catch (error) {
+            throw new Error(`최근 작업 현황 조회 실패: ${error.message}`);
+        }
+    }
+
+    // 요일별 패턴 분석
+    async getWeekdayPattern(startDate, endDate) {
+        const query = `
+            SELECT 
+                DAYOFWEEK(report_date) as day_of_week,
+                CASE DAYOFWEEK(report_date)
+                    WHEN 1 THEN '일요일'
+                    WHEN 2 THEN '월요일'
+                    WHEN 3 THEN '화요일'
+                    WHEN 4 THEN '수요일'
+                    WHEN 5 THEN '목요일'
+                    WHEN 6 THEN '금요일'
+                    WHEN 7 THEN '토요일'
+                END as day_name,
+                SUM(work_hours) as total_hours,
+                COUNT(*) as total_reports,
+                ROUND(AVG(work_hours), 2) as avg_hours,
+                COUNT(DISTINCT worker_id) as active_workers
+            FROM daily_work_reports
+            WHERE report_date BETWEEN ? AND ?
+            GROUP BY DAYOFWEEK(report_date)
+            ORDER BY day_of_week
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [startDate, endDate]);
+            return results.map(row => ({
+                dayOfWeek: row.day_of_week,
+                dayName: row.day_name,
+                totalHours: parseFloat(row.total_hours) || 0,
+                totalReports: parseInt(row.total_reports) || 0,
+                avgHours: parseFloat(row.avg_hours) || 0,
+                activeWorkers: parseInt(row.active_workers) || 0
+            }));
+        } catch (error) {
+            throw new Error(`요일별 패턴 분석 실패: ${error.message}`);
+        }
+    }
+
+    // 에러 분석
+    async getErrorAnalysis(startDate, endDate) {
+        const query = `
+            SELECT 
+                dwr.error_type_id,
+                et.name as error_type_name,
+                COUNT(*) as error_count,
+                SUM(dwr.work_hours) as total_hours,
+                COUNT(DISTINCT dwr.worker_id) as affected_workers,
+                COUNT(DISTINCT dwr.project_id) as affected_projects
+            FROM daily_work_reports dwr
+            LEFT JOIN error_types et ON dwr.error_type_id = et.id
+            WHERE dwr.report_date BETWEEN ? AND ?
+            AND dwr.work_status_id = 2
+            GROUP BY dwr.error_type_id, et.name
+            ORDER BY error_count DESC
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [startDate, endDate]);
+            return results.map(row => ({
+                error_type_id: row.error_type_id,
+                error_type_name: row.error_type_name || `에러유형 ${row.error_type_id}`,
+                errorCount: parseInt(row.error_count) || 0,
+                totalHours: parseFloat(row.total_hours) || 0,
+                affectedWorkers: parseInt(row.affected_workers) || 0,
+                affectedProjects: parseInt(row.affected_projects) || 0
+            }));
+        } catch (error) {
+            throw new Error(`에러 분석 실패: ${error.message}`);
+        }
+    }
+
+    // 월별 비교 분석
+    async getMonthlyComparison(year) {
+        const query = `
+            SELECT 
+                MONTH(report_date) as month,
+                MONTHNAME(report_date) as month_name,
+                SUM(work_hours) as total_hours,
+                COUNT(*) as total_reports,
+                COUNT(DISTINCT worker_id) as active_workers,
+                COUNT(DISTINCT project_id) as active_projects,
+                SUM(CASE WHEN work_status_id = 2 THEN 1 ELSE 0 END) as error_count
+            FROM daily_work_reports
+            WHERE YEAR(report_date) = ?
+            GROUP BY MONTH(report_date), MONTHNAME(report_date)
+            ORDER BY month
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [year]);
+            return results.map(row => ({
+                month: row.month,
+                monthName: row.month_name,
+                totalHours: parseFloat(row.total_hours) || 0,
+                totalReports: parseInt(row.total_reports) || 0,
+                activeWorkers: parseInt(row.active_workers) || 0,
+                activeProjects: parseInt(row.active_projects) || 0,
+                errorCount: parseInt(row.error_count) || 0,
+                errorRate: row.total_reports > 0 ? parseFloat(((row.error_count / row.total_reports) * 100).toFixed(2)) : 0
+            }));
+        } catch (error) {
+            throw new Error(`월별 비교 분석 실패: ${error.message}`);
+        }
+    }
+
+    // 작업자별 전문분야 분석
+    async getWorkerSpecialization(startDate, endDate) {
+        const query = `
+            SELECT 
+                dwr.worker_id,
+                w.worker_name,
+                dwr.work_type_id,
+                wt.name as work_type_name,
+                dwr.project_id,
+                p.project_name,
+                SUM(dwr.work_hours) as totalHours,
+                COUNT(*) as totalReports,
+                ROUND((SUM(dwr.work_hours) / (
+                    SELECT SUM(work_hours) 
+                    FROM daily_work_reports 
+                    WHERE worker_id = dwr.worker_id 
+                    AND report_date BETWEEN ? AND ?
+                )) * 100, 2) as percentage
+            FROM daily_work_reports dwr
+            LEFT JOIN Workers w ON dwr.worker_id = w.worker_id
+            LEFT JOIN work_types wt ON dwr.work_type_id = wt.id
+            LEFT JOIN Projects p ON dwr.project_id = p.project_id
+            WHERE dwr.report_date BETWEEN ? AND ?
+            GROUP BY dwr.worker_id, w.worker_name, dwr.work_type_id, wt.name, dwr.project_id, p.project_name
+            HAVING totalHours > 0
+            ORDER BY dwr.worker_id, totalHours DESC
+        `;
+
+        try {
+            const [results] = await this.db.execute(query, [startDate, endDate, startDate, endDate]);
+            return results.map(row => ({
+                worker_id: row.worker_id,
+                worker_name: row.worker_name || `작업자 ${row.worker_id}`,
+                work_type_id: row.work_type_id,
+                work_type_name: row.work_type_name || `작업유형 ${row.work_type_id}`,
+                project_id: row.project_id,
+                project_name: row.project_name || `프로젝트 ${row.project_id}`,
+                totalHours: parseFloat(row.totalHours) || 0,
+                totalReports: parseInt(row.totalReports) || 0,
+                percentage: parseFloat(row.percentage) || 0
+            }));
+        } catch (error) {
+            throw new Error(`작업자별 전문분야 분석 실패: ${error.message}`);
+        }
+    }
+
+    // 대시보드용 종합 데이터
+    async getDashboardData(startDate, endDate) {
+        try {
+            // 병렬로 모든 데이터 조회
+            const [
+                stats,
+                dailyTrend,
+                workerStats,
+                projectStats,
+                workTypeStats,
+                recentWork
+            ] = await Promise.all([
+                this.getBasicStats(startDate, endDate),
+                this.getDailyTrend(startDate, endDate),
+                this.getWorkerStats(startDate, endDate),
+                this.getProjectStats(startDate, endDate),
+                this.getWorkTypeStats(startDate, endDate),
+                this.getRecentWork(startDate, endDate, 20)
+            ]);
+
+            return {
+                stats,
+                dailyTrend,
+                workerStats,
+                projectStats,
+                workTypeStats,
+                recentWork,
+                metadata: {
+                    period: `${startDate} ~ ${endDate}`,
+                    timestamp: new Date().toISOString()
+                }
+            };
+        } catch (error) {
+            throw new Error(`대시보드 데이터 조회 실패: ${error.message}`);
+        }
+    }
+}
+
+module.exports = WorkAnalysis;

api.hyungi.net/models/cuttingPlanModel.js

@@ -0,0 +1,89 @@
+const { getDb } = require('../dbPool');
+
+const create = async (plan, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      project_id, drawing_name,
+      pipe_spec, area_number,
+      spool_number, length
+    } = plan;
+
+    const [result] = await db.query(
+      `INSERT INTO CuttingPlan
+       (project_id, drawing_name, pipe_spec, area_number, spool_number, length)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [project_id, drawing_name, pipe_spec, area_number, spool_number, length]
+    );
+
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const getAll = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM CuttingPlan ORDER BY cutting_plan_id DESC`
+    );
+    callback(null, rows);
+  } catch (err) {
+    callback(new Error(err.message || String(err)));
+  }
+};
+
+const getById = async (cutting_plan_id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM CuttingPlan WHERE cutting_plan_id = ?`,
+      [cutting_plan_id]
+    );
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const update = async (plan, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      cutting_plan_id, project_id, drawing_name,
+      pipe_spec, area_number, spool_number, length
+    } = plan;
+
+    const [result] = await db.query(
+      `UPDATE CuttingPlan
+       SET project_id    = ?,
+           drawing_name  = ?,
+           pipe_spec     = ?,
+           area_number   = ?,
+           spool_number  = ?,
+           length        = ?
+       WHERE cutting_plan_id = ?`,
+      [project_id, drawing_name, pipe_spec, area_number, spool_number, length, cutting_plan_id]
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const remove = async (cutting_plan_id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `DELETE FROM CuttingPlan WHERE cutting_plan_id = ?`,
+      [cutting_plan_id]
+    );
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+module.exports = { create, getAll, getById, update, remove };

api.hyungi.net/models/dailyIssueReportModel.js

@@ -0,0 +1,123 @@
+const { getDb } = require('../dbPool');
+
+/**
+ * 1. 등록 (단일 레코드)
+ */
+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);
+  }
+};
+
+/**
+ * 2. 특정 날짜의 전체 이슈 목록 조회
+ */
+const getAllByDate = async (date, callback) => {
+  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]
+    );
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+/**
+ * 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. 삭제
+ */
+const remove = async (id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(`DELETE FROM DailyIssueReports WHERE id = ?`, [id]);
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+module.exports = {
+  create,
+  getAllByDate,
+  getById,
+  update,
+  remove
+};

api.hyungi.net/models/dailyWorkReportModel.js

@@ -0,0 +1,830 @@
+// models/dailyWorkReportModel.js - 누적입력 방식 + 모든 기존 기능 포함
+const { getDb } = require('../dbPool');
+
+/**
+ * 📋 마스터 데이터 조회 함수들
+ */
+const getAllWorkTypes = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query('SELECT * FROM work_types ORDER BY name ASC');
+    callback(null, rows);
+  } catch (err) {
+    console.error('작업 유형 조회 오류:', err);
+    callback(err);
+  }
+};
+
+const getAllWorkStatusTypes = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query('SELECT * FROM work_status_types ORDER BY id ASC');
+    callback(null, rows);
+  } catch (err) {
+    console.error('업무 상태 유형 조회 오류:', err);
+    callback(err);
+  }
+};
+
+const getAllErrorTypes = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query('SELECT * FROM error_types ORDER BY name ASC');
+    callback(null, rows);
+  } catch (err) {
+    console.error('에러 유형 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 🔄 누적 추가 전용 함수 (createDailyReport 대체) - 절대 삭제 안함!
+ */
+const createDailyReport = async (reportData, callback) => {
+  const { report_date, worker_id, work_entries, created_by, created_by_name, total_hours } = reportData;
+  const db = await getDb();
+  const conn = await db.getConnection();
+
+  try {
+    await conn.beginTransaction();
+
+    console.log(`📝 ${created_by_name}이 ${report_date} ${worker_id}번 작업자에게 데이터 추가 중...`);
+
+   // ✅ 수정된 쿼리 (테이블 alias 추가):
+const [existingReports] = await conn.query(
+  `SELECT dwr.created_by, u.name as created_by_name, COUNT(*) as count, SUM(dwr.work_hours) as total_hours
+   FROM daily_work_reports dwr
+   LEFT JOIN Users u ON dwr.created_by = u.user_id
+   WHERE dwr.report_date = ? AND dwr.worker_id = ?
+   GROUP BY dwr.created_by`,
+  [report_date, worker_id]
+);
+
+
+    console.log('기존 데이터 (삭제하지 않음):', existingReports);
+
+    // 2. ✅ 삭제 없이 새로운 데이터만 추가!
+    const insertedIds = [];
+    for (const entry of work_entries) {
+      const { project_id, work_type_id, work_status_id, error_type_id, work_hours } = entry;
+      
+      const [insertResult] = await conn.query(
+        `INSERT INTO daily_work_reports 
+         (report_date, worker_id, project_id, work_type_id, work_status_id, error_type_id, work_hours, created_by, created_at) 
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, NOW())`,
+        [report_date, worker_id, project_id, work_type_id, work_status_id || 1, error_type_id || null, work_hours, created_by]
+      );
+      
+      insertedIds.push(insertResult.insertId);
+    }
+
+   // ✅ 수정된 쿼리:
+const [finalReports] = await conn.query(
+  `SELECT dwr.created_by, u.name as created_by_name, COUNT(*) as count, SUM(dwr.work_hours) as total_hours
+   FROM daily_work_reports dwr
+   LEFT JOIN Users u ON dwr.created_by = u.user_id
+   WHERE dwr.report_date = ? AND dwr.worker_id = ?
+   GROUP BY dwr.created_by`,
+  [report_date, worker_id]
+);
+
+    const grandTotal = finalReports.reduce((sum, report) => sum + parseFloat(report.total_hours || 0), 0);
+    const myTotal = finalReports.find(r => r.created_by === created_by)?.total_hours || 0;
+
+    console.log('최종 결과:');
+    finalReports.forEach(report => {
+      console.log(`  - ${report.created_by_name}: ${report.total_hours}시간 (${report.count}개 항목)`);
+    });
+    console.log(`  📊 총합: ${grandTotal}시간`);
+
+    // 4. 감사 로그 추가
+    try {
+      await conn.query(
+        `INSERT INTO work_report_audit_log 
+         (action, report_id, new_values, changed_by, change_reason, created_at) 
+         VALUES (?, ?, ?, ?, ?, NOW())`,
+        [
+          'ADD_ACCUMULATE', 
+          insertedIds[0] || null,
+          JSON.stringify({
+            report_date,
+            worker_id,
+            work_entries_count: work_entries.length,
+            added_hours: total_hours,
+            my_total: myTotal,
+            grand_total: grandTotal,
+            contributors: finalReports.map(r => ({ name: r.created_by_name, hours: r.total_hours }))
+          }),
+          created_by,
+          `누적 추가 by ${created_by_name} - 삭제 없음`
+        ]
+      );
+    } catch (auditErr) {
+      console.warn('감사 로그 추가 실패:', auditErr.message);
+    }
+
+    await conn.commit();
+    
+    callback(null, { 
+      success: true, 
+      inserted_count: insertedIds.length,
+      deleted_count: 0, // 항상 0 (삭제 안함)
+      action: 'accumulated',
+      message: `${created_by_name}이 ${total_hours}시간 추가했습니다. (개인 총 ${myTotal}시간, 전체 총 ${grandTotal}시간)`,
+      final_summary: {
+        my_total: parseFloat(myTotal),
+        grand_total: grandTotal,
+        total_contributors: finalReports.length,
+        contributors: finalReports
+      }
+    });
+    
+  } catch (err) {
+    await conn.rollback();
+    console.error('작업보고서 누적 추가 오류:', err);
+    callback(err);
+  } finally {
+    conn.release();
+  }
+};
+
+/**
+ * 📊 특정 날짜 + 작업자 + 작성자의 누적 현황 조회
+ */
+const getMyAccumulatedHours = async (date, worker_id, created_by, callback) => {
+  try {
+    const db = await getDb();
+    
+    const sql = `
+      SELECT 
+        SUM(work_hours) as my_total_hours,
+        COUNT(*) as my_entry_count,
+        GROUP_CONCAT(
+          CONCAT(p.project_name, ':', work_hours, 'h') 
+          ORDER BY created_at
+        ) as my_entries
+      FROM daily_work_reports dwr
+      LEFT JOIN Projects p ON dwr.project_id = p.project_id
+      WHERE dwr.report_date = ? AND dwr.worker_id = ? AND dwr.created_by = ?
+    `;
+    
+    const [rows] = await db.query(sql, [date, worker_id, created_by]);
+    callback(null, rows[0] || { my_total_hours: 0, my_entry_count: 0, my_entries: null });
+  } catch (err) {
+    console.error('개인 누적 현황 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 📊 누적 현황 조회 - 날짜+작업자별 (모든 기여자)
+ */
+const getAccumulatedReportsByDate = async (date, worker_id, callback) => {
+  try {
+    const db = await getDb();
+    
+    const sql = getSelectQuery() + `
+      WHERE dwr.report_date = ? AND dwr.worker_id = ?
+      ORDER BY dwr.created_by, dwr.created_at ASC
+    `;
+    
+    const [rows] = await db.query(sql, [date, worker_id]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('누적 현황 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 📊 기여자별 요약 조회
+ */
+const getContributorsByDate = async (date, worker_id, callback) => {
+  try {
+    const db = await getDb();
+    
+    const sql = `
+      SELECT 
+        dwr.created_by,
+        u.name as created_by_name,
+        COUNT(*) as entry_count,
+        SUM(dwr.work_hours) as total_hours,
+        MIN(dwr.created_at) as first_entry,
+        MAX(dwr.created_at) as last_entry,
+        GROUP_CONCAT(
+          CONCAT(p.project_name, ':', dwr.work_hours, 'h') 
+          ORDER BY dwr.created_at SEPARATOR ', '
+        ) as entry_details
+      FROM daily_work_reports dwr
+      LEFT JOIN Users u ON dwr.created_by = u.user_id
+      LEFT JOIN Projects p ON dwr.project_id = p.project_id
+      WHERE dwr.report_date = ? AND dwr.worker_id = ?
+      GROUP BY dwr.created_by
+      ORDER BY total_hours DESC, first_entry ASC
+    `;
+    
+    const [rows] = await db.query(sql, [date, worker_id]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('기여자별 요약 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 🗑️ 특정 작업 항목만 삭제 (개별 삭제)
+ */
+const removeSpecificEntry = async (entry_id, deleted_by, callback) => {
+  const db = await getDb();
+  const conn = await db.getConnection();
+  
+  try {
+    await conn.beginTransaction();
+    
+    // 삭제 전 정보 확인
+    const [entryInfo] = await conn.query(
+      `SELECT dwr.*, w.worker_name, p.project_name, u.name as created_by_name
+       FROM daily_work_reports dwr
+       LEFT JOIN Workers w ON dwr.worker_id = w.worker_id
+       LEFT JOIN Projects p ON dwr.project_id = p.project_id
+       LEFT JOIN Users u ON dwr.created_by = u.user_id
+       WHERE dwr.id = ?`,
+      [entry_id]
+    );
+
+    if (entryInfo.length === 0) {
+      await conn.rollback();
+      return callback(new Error('삭제할 항목을 찾을 수 없습니다.'));
+    }
+
+    const entry = entryInfo[0];
+
+    // 권한 확인: 본인이 작성한 것만 삭제 가능
+    if (entry.created_by !== deleted_by) {
+      await conn.rollback();
+      return callback(new Error('본인이 작성한 항목만 삭제할 수 있습니다.'));
+    }
+
+    // 개별 항목 삭제
+    const [result] = await conn.query('DELETE FROM daily_work_reports WHERE id = ?', [entry_id]);
+    
+    // 감사 로그
+    try {
+      await conn.query(
+        `INSERT INTO work_report_audit_log 
+         (action, report_id, old_values, changed_by, change_reason, created_at) 
+         VALUES (?, ?, ?, ?, ?, NOW())`,
+        [
+          'DELETE_SINGLE', 
+          entry_id,
+          JSON.stringify({
+            worker_name: entry.worker_name,
+            project_name: entry.project_name,
+            work_hours: entry.work_hours,
+            report_date: entry.report_date
+          }),
+          deleted_by,
+          `개별 항목 삭제`
+        ]
+      );
+    } catch (auditErr) {
+      console.warn('감사 로그 추가 실패:', auditErr.message);
+    }
+
+    await conn.commit();
+    callback(null, { 
+      success: true,
+      deleted_entry: {
+        worker_name: entry.worker_name,
+        project_name: entry.project_name,
+        work_hours: entry.work_hours
+      }
+    });
+    
+  } catch (err) {
+    await conn.rollback();
+    console.error('개별 항목 삭제 오류:', err);
+    callback(err);
+  } finally {
+    conn.release();
+  }
+};
+
+/**
+ * 공통 SELECT 쿼리 부분
+ */
+const getSelectQuery = () => `
+  SELECT 
+    dwr.id,
+    dwr.report_date,
+    dwr.worker_id,
+    dwr.project_id,
+    dwr.work_type_id,
+    dwr.work_status_id,
+    dwr.error_type_id,
+    dwr.work_hours,
+    dwr.created_by,
+    w.worker_name,
+    p.project_name,
+    wt.name as work_type_name,
+    wst.name as work_status_name,
+    et.name as error_type_name,
+    u.name as created_by_name,
+    dwr.created_at,
+    dwr.updated_at
+  FROM daily_work_reports dwr
+  LEFT JOIN Workers w ON dwr.worker_id = w.worker_id
+  LEFT JOIN Projects p ON dwr.project_id = p.project_id
+  LEFT JOIN work_types wt ON dwr.work_type_id = wt.id
+  LEFT JOIN work_status_types wst ON dwr.work_status_id = wst.id
+  LEFT JOIN error_types et ON dwr.error_type_id = et.id
+  LEFT JOIN Users u ON dwr.created_by = u.user_id
+`;
+
+/**
+ * 7. ID로 작업보고서 조회
+ */
+const getById = async (id, callback) => {
+  try {
+    const db = await getDb();
+    const sql = getSelectQuery() + 'WHERE dwr.id = ?';
+    const [rows] = await db.query(sql, [id]);
+    callback(null, rows[0] || null);
+  } catch (err) {
+    console.error('ID로 작업보고서 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 8. 일일 작업보고서 조회 (날짜별)
+ */
+const getByDate = async (date, callback) => {
+  try {
+    const db = await getDb();
+    const sql = getSelectQuery() + `
+      WHERE dwr.report_date = ?
+      ORDER BY w.worker_name ASC, p.project_name ASC, dwr.id ASC
+    `;
+    const [rows] = await db.query(sql, [date]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('날짜별 작업보고서 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 9. 일일 작업보고서 조회 (날짜 + 작성자별)
+ */
+const getByDateAndCreator = async (date, created_by, callback) => {
+  try {
+    const db = await getDb();
+    const sql = getSelectQuery() + `
+      WHERE dwr.report_date = ? AND dwr.created_by = ?
+      ORDER BY w.worker_name ASC, p.project_name ASC, dwr.id ASC
+    `;
+    const [rows] = await db.query(sql, [date, created_by]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('날짜+작성자별 작업보고서 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 10. 일일 작업보고서 조회 (작업자별)
+ */
+const getByWorker = async (worker_id, callback) => {
+  try {
+    const db = await getDb();
+    const sql = getSelectQuery() + `
+      WHERE dwr.worker_id = ?
+      ORDER BY dwr.report_date DESC, dwr.id ASC
+    `;
+    const [rows] = await db.query(sql, [worker_id]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('작업자별 작업보고서 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 11. 일일 작업보고서 조회 (날짜 + 작업자)
+ */
+const getByDateAndWorker = async (date, worker_id, callback) => {
+  try {
+    const db = await getDb();
+    const sql = getSelectQuery() + `
+      WHERE dwr.report_date = ? AND dwr.worker_id = ?
+      ORDER BY dwr.id ASC
+    `;
+    const [rows] = await db.query(sql, [date, worker_id]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('날짜+작업자별 작업보고서 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 12. 기간별 조회
+ */
+const getByRange = async (start_date, end_date, callback) => {
+  try {
+    const db = await getDb();
+    const sql = getSelectQuery() + `
+      WHERE dwr.report_date BETWEEN ? AND ?
+      ORDER BY dwr.report_date DESC, w.worker_name ASC, dwr.id ASC
+    `;
+    const [rows] = await db.query(sql, [start_date, end_date]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('기간별 작업보고서 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 13. 상세 검색 (페이지네이션 포함)
+ */
+const searchWithDetails = async (params, callback) => {
+  const { start_date, end_date, worker_id, project_id, work_status_id, created_by, page, limit } = params;
+  
+  try {
+    const db = await getDb();
+    
+    // 조건 구성
+    let whereConditions = ['dwr.report_date BETWEEN ? AND ?'];
+    let queryParams = [start_date, end_date];
+
+    if (worker_id) {
+      whereConditions.push('dwr.worker_id = ?');
+      queryParams.push(worker_id);
+    }
+
+    if (project_id) {
+      whereConditions.push('dwr.project_id = ?');
+      queryParams.push(project_id);
+    }
+
+    if (work_status_id) {
+      whereConditions.push('dwr.work_status_id = ?');
+      queryParams.push(work_status_id);
+    }
+
+    if (created_by) {
+      whereConditions.push('dwr.created_by = ?');
+      queryParams.push(created_by);
+    }
+
+    const whereClause = whereConditions.join(' AND ');
+    
+    // 총 개수 조회
+    const countQuery = `
+      SELECT COUNT(*) as total 
+      FROM daily_work_reports dwr 
+      WHERE ${whereClause}
+    `;
+    const [countResult] = await db.query(countQuery, queryParams);
+    const total = countResult[0].total;
+
+    // 데이터 조회 (JOIN 포함)
+    const offset = (page - 1) * limit;
+    const dataQuery = getSelectQuery() + `
+      WHERE ${whereClause}
+      ORDER BY dwr.report_date DESC, w.worker_name ASC, dwr.created_at DESC
+      LIMIT ? OFFSET ?
+    `;
+    
+    const dataParams = [...queryParams, limit, offset];
+    const [rows] = await db.query(dataQuery, dataParams);
+
+    callback(null, { reports: rows, total });
+  } catch (err) {
+    console.error('상세 검색 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 14. 일일 근무 요약 조회 (날짜별)
+ */
+const getSummaryByDate = async (date, callback) => {
+  try {
+    const db = await getDb();
+    
+    const sql = `
+      SELECT 
+        dwr.worker_id,
+        w.worker_name,
+        dwr.report_date,
+        SUM(dwr.work_hours) as total_hours,
+        COUNT(*) as work_entries_count,
+        SUM(CASE WHEN dwr.work_status_id = 2 THEN 1 ELSE 0 END) as error_count
+      FROM daily_work_reports dwr
+      LEFT JOIN Workers w ON dwr.worker_id = w.worker_id
+      WHERE dwr.report_date = ?
+      GROUP BY dwr.worker_id, dwr.report_date
+      ORDER BY w.worker_name ASC
+    `;
+    const [rows] = await db.query(sql, [date]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('일일 근무 요약 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 15. 일일 근무 요약 조회 (작업자별)
+ */
+const getSummaryByWorker = async (worker_id, callback) => {
+  try {
+    const db = await getDb();
+    
+    const sql = `
+      SELECT 
+        dwr.report_date,
+        dwr.worker_id,
+        w.worker_name,
+        SUM(dwr.work_hours) as total_hours,
+        COUNT(*) as work_entries_count,
+        SUM(CASE WHEN dwr.work_status_id = 2 THEN 1 ELSE 0 END) as error_count
+      FROM daily_work_reports dwr
+      LEFT JOIN Workers w ON dwr.worker_id = w.worker_id
+      WHERE dwr.worker_id = ?
+      GROUP BY dwr.report_date, dwr.worker_id
+      ORDER BY dwr.report_date DESC
+    `;
+    const [rows] = await db.query(sql, [worker_id]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('작업자별 근무 요약 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 16. 월간 요약
+ */
+const getMonthlySummary = async (year, month, callback) => {
+  try {
+    const db = await getDb();
+    const start = `${year.padStart(4, '0')}-${month.padStart(2, '0')}-01`;
+    const end = `${year.padStart(4, '0')}-${month.padStart(2, '0')}-31`;
+    
+    const sql = `
+      SELECT 
+        dwr.report_date,
+        dwr.worker_id,
+        w.worker_name,
+        SUM(dwr.work_hours) as total_work_hours,
+        COUNT(DISTINCT dwr.project_id) as project_count,
+        COUNT(*) as work_entries_count,
+        SUM(CASE WHEN dwr.work_status_id = 2 THEN 1 ELSE 0 END) as error_count,
+        GROUP_CONCAT(DISTINCT p.project_name ORDER BY p.project_name) as projects,
+        GROUP_CONCAT(DISTINCT wt.name ORDER BY wt.name) as work_types
+      FROM daily_work_reports dwr
+      LEFT JOIN Workers w ON dwr.worker_id = w.worker_id
+      LEFT JOIN Projects p ON dwr.project_id = p.project_id
+      LEFT JOIN work_types wt ON dwr.work_type_id = wt.id
+      WHERE dwr.report_date BETWEEN ? AND ?
+      GROUP BY dwr.report_date, dwr.worker_id
+      ORDER BY dwr.report_date DESC, w.worker_name ASC
+    `;
+    const [rows] = await db.query(sql, [start, end]);
+    callback(null, rows);
+  } catch (err) {
+    console.error('월간 요약 조회 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 17. 작업보고서 수정
+ */
+const updateById = async (id, updateData, callback) => {
+  try {
+    const db = await getDb();
+    
+    const setFields = [];
+    const values = [];
+    
+    if (updateData.work_hours !== undefined) {
+      setFields.push('work_hours = ?');
+      values.push(updateData.work_hours);
+    }
+    
+    if (updateData.work_status_id !== undefined) {
+      setFields.push('work_status_id = ?');
+      values.push(updateData.work_status_id);
+    }
+    
+    if (updateData.error_type_id !== undefined) {
+      setFields.push('error_type_id = ?');
+      values.push(updateData.error_type_id);
+    }
+    
+    if (updateData.project_id !== undefined) {
+      setFields.push('project_id = ?');
+      values.push(updateData.project_id);
+    }
+    
+    if (updateData.work_type_id !== undefined) {
+      setFields.push('work_type_id = ?');
+      values.push(updateData.work_type_id);
+    }
+    
+    setFields.push('updated_at = NOW()');
+    
+    if (updateData.updated_by) {
+      setFields.push('updated_by = ?');
+      values.push(updateData.updated_by);
+    }
+    
+    values.push(id);
+    
+    const sql = `UPDATE daily_work_reports SET ${setFields.join(', ')} WHERE id = ?`;
+    const [result] = await db.query(sql, values);
+    
+    callback(null, result.affectedRows);
+  } catch (err) {
+    console.error('작업보고서 수정 오류:', err);
+    callback(err);
+  }
+};
+
+/**
+ * 18. 특정 작업보고서 삭제
+ */
+const removeById = async (id, deletedBy, callback) => {
+  const db = await getDb();
+  const conn = await db.getConnection();
+  
+  try {
+    await conn.beginTransaction();
+    
+    // 삭제 전 정보 저장 (감사 로그용)
+    const [reportInfo] = await conn.query('SELECT * FROM daily_work_reports WHERE id = ?', [id]);
+    
+    // 작업보고서 삭제
+    const [result] = await conn.query('DELETE FROM daily_work_reports WHERE id = ?', [id]);
+    
+    // 감사 로그 추가
+    if (reportInfo.length > 0 && deletedBy) {
+      try {
+        await conn.query(
+          `INSERT INTO work_report_audit_log 
+           (action, report_id, old_values, changed_by, change_reason, created_at) 
+           VALUES ('DELETE', ?, ?, ?, 'Manual deletion', NOW())`,
+          [id, JSON.stringify(reportInfo[0]), deletedBy]
+        );
+      } catch (auditErr) {
+        console.warn('감사 로그 추가 실패:', auditErr.message);
+      }
+    }
+    
+    await conn.commit();
+    callback(null, result.affectedRows);
+  } catch (err) {
+    await conn.rollback();
+    console.error('작업보고서 삭제 오류:', err);
+    callback(err);
+  } finally {
+    conn.release();
+  }
+};
+
+/**
+ * 19. 작업자의 특정 날짜 전체 삭제
+ */
+const removeByDateAndWorker = async (date, worker_id, deletedBy, callback) => {
+  const db = await getDb();
+  const conn = await db.getConnection();
+  
+  try {
+    await conn.beginTransaction();
+    
+    // 삭제 전 정보 저장 (감사 로그용)
+    const [reportInfos] = await conn.query(
+      'SELECT * FROM daily_work_reports WHERE report_date = ? AND worker_id = ?', 
+      [date, worker_id]
+    );
+    
+    // 작업보고서 삭제
+    const [result] = await conn.query(
+      'DELETE FROM daily_work_reports WHERE report_date = ? AND worker_id = ?',
+      [date, worker_id]
+    );
+    
+    // 감사 로그 추가
+    if (reportInfos.length > 0 && deletedBy) {
+      try {
+        await conn.query(
+          `INSERT INTO work_report_audit_log 
+           (action, old_values, changed_by, change_reason, created_at) 
+           VALUES ('DELETE_BATCH', ?, ?, 'Batch deletion by date and worker', NOW())`,
+          [JSON.stringify({ deleted_reports: reportInfos, count: reportInfos.length }), deletedBy]
+        );
+      } catch (auditErr) {
+        console.warn('감사 로그 추가 실패:', auditErr.message);
+      }
+    }
+    
+    await conn.commit();
+    callback(null, result.affectedRows);
+  } catch (err) {
+    await conn.rollback();
+    console.error('작업보고서 전체 삭제 오류:', err);
+    callback(err);
+  } finally {
+    conn.release();
+  }
+};
+
+/**
+ * 20. 통계 조회
+ */
+const getStatistics = async (start_date, end_date, callback) => {
+  try {
+    const db = await getDb();
+    
+    const sql = `
+      SELECT 
+        COUNT(*) as total_reports,
+        SUM(work_hours) as total_hours,
+        COUNT(DISTINCT worker_id) as unique_workers,
+        COUNT(DISTINCT project_id) as unique_projects,
+        SUM(CASE WHEN work_status_id = 2 THEN 1 ELSE 0 END) as error_count,
+        AVG(work_hours) as avg_hours_per_entry,
+        MIN(work_hours) as min_hours,
+        MAX(work_hours) as max_hours
+      FROM daily_work_reports
+      WHERE report_date BETWEEN ? AND ?
+    `;
+    
+    const [rows] = await db.query(sql, [start_date, end_date]);
+    
+    // 추가 통계 - 날짜별 집계
+    const dailyStatsSql = `
+      SELECT 
+        report_date,
+        COUNT(*) as daily_reports,
+        SUM(work_hours) as daily_hours,
+        COUNT(DISTINCT worker_id) as daily_workers
+      FROM daily_work_reports
+      WHERE report_date BETWEEN ? AND ?
+      GROUP BY report_date
+      ORDER BY report_date DESC
+    `;
+    
+    const [dailyStats] = await db.query(dailyStatsSql, [start_date, end_date]);
+    
+    const result = {
+      overall: rows[0],
+      daily_breakdown: dailyStats
+    };
+    
+    callback(null, result);
+  } catch (err) {
+    console.error('통계 조회 오류:', err);
+    callback(err);
+  }
+};
+
+// 모든 함수 내보내기 (기존 기능 + 누적 기능)
+module.exports = {
+  // 📋 마스터 데이터
+  getAllWorkTypes,
+  getAllWorkStatusTypes,
+  getAllErrorTypes,
+  
+  // 🔄 핵심 생성 함수 (누적 방식)
+  createDailyReport,              // 누적 추가 (덮어쓰기 없음)
+  
+  // 📊 누적 관련 새로운 함수들
+  getMyAccumulatedHours,          // 개인 누적 현황
+  getAccumulatedReportsByDate,    // 날짜별 누적 현황
+  getContributorsByDate,          // 기여자별 요약
+  removeSpecificEntry,            // 개별 항목 삭제
+  
+  // 📊 기존 조회 함수들 (모두 유지)
+  getById,
+  getByDate,
+  getByDateAndCreator,           // 날짜+작성자별 조회
+  getByWorker,
+  getByDateAndWorker,
+  getByRange,
+  searchWithDetails,
+  getSummaryByDate,
+  getSummaryByWorker,
+  getMonthlySummary,
+  
+  // ✏️ 수정/삭제 함수들 (기존 유지)
+  updateById,
+  removeById,
+  removeByDateAndWorker,
+  getStatistics
+};

api.hyungi.net/models/equipmentListModel.js

@@ -0,0 +1,94 @@
+const { getDb } = require('../dbPool');
+
+const create = async (equipment, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      factory_id, equipment_name,
+      model, status, purchase_date, description
+    } = equipment;
+
+    const [result] = await db.query(
+      `INSERT INTO EquipmentList
+       (factory_id, equipment_name, model, status, purchase_date, description)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [factory_id, equipment_name, model, status, purchase_date, description]
+    );
+
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const getAll = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM EquipmentList ORDER BY equipment_id DESC`
+    );
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const getById = async (equipment_id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM EquipmentList WHERE equipment_id = ?`,
+      [equipment_id]
+    );
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const update = async (equipment, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      equipment_id, factory_id, equipment_name,
+      model, status, purchase_date, description
+    } = equipment;
+
+    const [result] = await db.query(
+      `UPDATE EquipmentList
+       SET factory_id    = ?,
+           equipment_name = ?,
+           model          = ?,
+           status         = ?,
+           purchase_date  = ?,
+           description    = ?
+       WHERE equipment_id = ?`,
+      [factory_id, equipment_name, model, status, purchase_date, description, equipment_id]
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(new Error(err.message || String(err)));
+  }
+};
+
+const remove = async (equipment_id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `DELETE FROM EquipmentList WHERE equipment_id = ?`,
+      [equipment_id]
+    );
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+module.exports = {
+  create,
+  getAll,
+  getById,
+  update,
+  remove
+};

api.hyungi.net/models/factoryInfoModel.js

@@ -0,0 +1,86 @@
+const { getDb } = require('../dbPool');
+
+const create = async (factory, callback) => {
+  try {
+    const db = await getDb();
+    const { factory_name, address, description, map_image_url } = factory;
+
+    const [result] = await db.query(
+      `INSERT INTO FactoryInfo
+       (factory_name, address, description, map_image_url)
+       VALUES (?, ?, ?, ?)`,
+      [factory_name, address, description, map_image_url]
+    );
+
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const getAll = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM FactoryInfo ORDER BY factory_id DESC`
+    );
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const getById = async (factory_id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM FactoryInfo WHERE factory_id = ?`,
+      [factory_id]
+    );
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const update = async (factory, callback) => {
+  try {
+    const db = await getDb();
+    const { factory_id, factory_name, address, description, map_image_url } = factory;
+
+    const [result] = await db.query(
+      `UPDATE FactoryInfo
+       SET factory_name  = ?,
+           address       = ?,
+           description   = ?,
+           map_image_url = ?
+       WHERE factory_id = ?`,
+      [factory_name, address, description, map_image_url, factory_id]
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(new Error(err.message || String(err)));
+  }
+};
+
+const remove = async (factory_id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `DELETE FROM FactoryInfo WHERE factory_id = ?`,
+      [factory_id]
+    );
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+module.exports = {
+  create,
+  getAll,
+  getById,
+  update,
+  remove
+};

api.hyungi.net/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
+};

api.hyungi.net/models/pingModel.js

@@ -0,0 +1,12 @@
+// models/pingModel.js
+
+/**
+ * 단순 ping 비즈니스 로직 레이어
+ * 필요하다면 여기서 더 복잡한 처리나 다른 서비스 호출 등을 관리
+ */
+exports.ping = () => {
+  return {
+    message: 'pong',
+    timestamp: new Date().toISOString()
+  };
+};

api.hyungi.net/models/pipeSpecModel.js

@@ -0,0 +1,31 @@
+const { getDb } = require('../dbPool');
+
+// 전체 조회
+const getAll = async () => {
+  const db = await getDb();
+  const [rows] = await db.query(`SELECT * FROM PipeSpecs ORDER BY material, diameter_in`);
+  return rows;
+};
+
+// 등록
+const create = async ({ material, diameter_in, schedule }) => {
+  const db = await getDb();
+  const [result] = await db.query(
+    `INSERT INTO PipeSpecs (material, diameter_in, schedule)
+     VALUES (?, ?, ?)`,
+    [material, diameter_in, schedule]
+  );
+  return result.insertId;
+};
+
+// 삭제
+const remove = async (spec_id) => {
+  const db = await getDb();
+  const [result] = await db.query(
+    `DELETE FROM PipeSpecs WHERE spec_id = ?`,
+    [spec_id]
+  );
+  return result.affectedRows;
+};
+
+module.exports = { getAll, create, remove };

api.hyungi.net/models/processModel.js

@@ -0,0 +1,100 @@
+const { getDb } = require('../dbPool');
+
+const create = async (processData, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      project_id, process_name,
+      process_start, process_end,
+      planned_worker_count, process_description, note
+    } = processData;
+
+    const [result] = await db.query(
+      `INSERT INTO Processes
+       (project_id, process_name, process_start, process_end,
+        planned_worker_count, process_description, note)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [project_id, process_name, process_start, process_end,
+       planned_worker_count, process_description, note]
+    );
+
+    callback(null, result.insertId);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const getAll = async (callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM Processes ORDER BY process_id DESC`
+    );
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const getById = async (process_id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM Processes WHERE process_id = ?`,
+      [process_id]
+    );
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+const update = async (processData, callback) => {
+  try {
+    const db = await getDb();
+    const {
+      process_id, project_id,
+      process_name, process_start, process_end,
+      planned_worker_count, process_description, note
+    } = processData;
+
+    const [result] = await db.query(
+      `UPDATE Processes
+       SET project_id            = ?,
+           process_name         = ?,
+           process_start        = ?,
+           process_end          = ?,
+           planned_worker_count = ?,
+           process_description  = ?,
+           note                 = ?
+       WHERE process_id = ?`,
+      [project_id, process_name, process_start, process_end,
+       planned_worker_count, process_description, note, process_id]
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(new Error(err.message || String(err)));
+  }
+};
+
+const remove = async (process_id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `DELETE FROM Processes WHERE process_id = ?`,
+      [process_id]
+    );
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+module.exports = {
+  create,
+  getAll,
+  getById,
+  update,
+  remove
+};

api.hyungi.net/models/projectModel.js

@@ -0,0 +1,97 @@
+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
+    } = project;
+  
+    const [result] = await db.query(
+      `INSERT INTO Projects
+       (job_no, project_name, contract_date, due_date, delivery_method, site, pm)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      [job_no, project_name, contract_date, due_date, delivery_method, site, pm]
+    );
+
+    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 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
+    } = project;
+
+    const [result] = await db.query(
+      `UPDATE Projects
+       SET job_no         = ?,
+           project_name   = ?,
+           contract_date  = ?,
+           due_date       = ?,
+           delivery_method= ?,
+           site           = ?,
+           pm             = ?
+       WHERE project_id = ?`,
+      [job_no, project_name, contract_date, due_date, delivery_method, site, pm, 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,
+  getById,
+  update,
+  remove
+};

api.hyungi.net/models/taskModel.js

@@ -0,0 +1,90 @@
+const { getDb } = require('../dbPool');
+
+// 1. 생성
+const create = async (task, callback) => {
+  try {
+    const db = await getDb();
+    const { category, subcategory, task_name, description } = task;
+
+    const [result] = await db.query(
+      `INSERT INTO Tasks (category, subcategory, task_name, description)
+       VALUES (?, ?, ?, ?)`,
+      [category, subcategory, task_name, description]
+    );
+
+    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 Tasks ORDER BY task_id DESC`
+    );
+    callback(null, rows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// 3. 단일 조회
+const getById = async (task_id, callback) => {
+  try {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT * FROM Tasks WHERE task_id = ?`,
+      [task_id]
+    );
+    callback(null, rows[0]);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// 4. 수정
+const update = async (task, callback) => {
+  try {
+    const db = await getDb();
+    const { task_id, category, subcategory, task_name, description } = task;
+
+    const [result] = await db.query(
+      `UPDATE Tasks
+       SET category     = ?,
+           subcategory  = ?,
+           task_name    = ?,
+           description  = ?
+       WHERE task_id    = ?`,
+      [category, subcategory, task_name, description, task_id]
+    );
+
+    callback(null, result.affectedRows);
+  } catch (err) {
+   callback(new Error(err.message || String(err)));
+  }
+};
+
+// 5. 삭제
+const remove = async (task_id, callback) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `DELETE FROM Tasks WHERE task_id = ?`,
+      [task_id]
+    );
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+module.exports = {
+  create,
+  getAll,
+  getById,
+  update,
+  remove
+};

api.hyungi.net/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
+};

api.hyungi.net/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
+};

api.hyungi.net/models/userModel.js

@@ -0,0 +1,20 @@
+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;
+  }
+};
+
+// 명확한 내보내기
+module.exports = {
+  findByUsername
+};

api.hyungi.net/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
+};

api.hyungi.net/models/workerModel.js

@@ -0,0 +1,89 @@
+const { getDb } = require('../dbPool');
+
+// 1. 작업자 생성
+const create = async (worker, callback) => {
+  try {
+    const db = await getDb();
+    const { worker_name, join_date, job_type, salary, annual_leave, status } = worker;
+
+    const [result] = await db.query(
+      `INSERT INTO Workers 
+       (worker_name, join_date, job_type, salary, annual_leave, status)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [worker_name, join_date, job_type, salary, annual_leave, 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) => {
+  try {
+    const db = await getDb();
+    const [result] = await db.query(
+      `DELETE FROM Workers WHERE worker_id = ?`,
+      [worker_id]
+    );
+    callback(null, result.affectedRows);
+  } catch (err) {
+    callback(err);
+  }
+};
+
+// ✅ 모듈 내보내기 (정상 구조)
+module.exports = {
+  create,
+  getAll,
+  getById,
+  update,
+  remove
+};