TK-FB-Project/api.hyungi.net/services/attendanceService.js

/**
 * 근태 관리 서비스
 *
 * 근태 기록 관련 비즈니스 로직 처리
 *
 * @author TK-FB-Project
 * @since 2025-12-11
 */

const AttendanceModel = require('../models/attendanceModel');
const { ValidationError, NotFoundError, DatabaseError } = require('../utils/errors');
const logger = require('../utils/logger');

/**
 * 일일 근태 현황 조회
 */
const getDailyAttendanceStatusService = async (date) => {
  if (!date) {
    throw new ValidationError('날짜가 필요합니다', {
      required: ['date'],
      received: { date }
    });
  }

  logger.info('일일 근태 현황 조회 요청', { date });

  try {
    // 조회 전 초기화 수행 (Lazy Initialization)
    // 생성자는 시스템(1) 또는 요청자가 될 수 있으나, 여기서는 안전하게 1(System/Admin) 사용 
    // 혹은 req.user가 없으므로 서비스 레벨에서는 1로 가정하거나 파라미터로 받아야 함. 
    // 서비스 인터페이스 변경 최소화를 위해 하드코딩 또는 안전장치.
    await AttendanceModel.initializeDailyRecords(date, 1);

    const attendanceStatus = await AttendanceModel.getWorkerAttendanceStatus(date);
    logger.info('일일 근태 현황 조회 성공', { date, count: attendanceStatus.length });
    return attendanceStatus;
  } catch (error) {
    logger.error('일일 근태 현황 조회 실패', { date, error: error.message });
    throw new DatabaseError('근태 현황 조회 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 일일 근태 기록 조회
 */
const getDailyAttendanceRecordsService = async (date, workerId = null) => {
  if (!date) {
    throw new ValidationError('날짜가 필요합니다', {
      required: ['date'],
      received: { date }
    });
  }

  logger.info('일일 근태 기록 조회 요청', { date, workerId });

  try {
    const records = await AttendanceModel.getDailyAttendanceRecords(date, workerId);
    logger.info('일일 근태 기록 조회 성공', { date, count: records.length });
    return records;
  } catch (error) {
    logger.error('일일 근태 기록 조회 실패', { date, error: error.message });
    throw new DatabaseError('근태 기록 조회 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 근태 기록 생성/업데이트
 */
const upsertAttendanceRecordService = async (recordData) => {
  const {
    record_date,
    worker_id,
    total_work_hours,
    attendance_type_id,
    vacation_type_id,
    is_vacation_processed,
    overtime_approved,
    status,
    notes,
    created_by
  } = recordData;

  // 필수 필드 검증
  if (!record_date || !worker_id) {
    throw new ValidationError('필수 필드가 누락되었습니다', {
      required: ['record_date', 'worker_id'],
      received: { record_date, worker_id }
    });
  }

  logger.info('근태 기록 저장 요청', { record_date, worker_id });

  try {
    const result = await AttendanceModel.upsertAttendanceRecord({
      record_date,
      worker_id,
      total_work_hours,
      attendance_type_id,
      vacation_type_id,
      is_vacation_processed,
      overtime_approved,
      status,
      notes,
      created_by
    });

    logger.info('근태 기록 저장 성공', { record_date, worker_id });
    return result;
  } catch (error) {
    logger.error('근태 기록 저장 실패', { record_date, worker_id, error: error.message });
    throw new DatabaseError('근태 기록 저장 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 휴가 처리
 */
const processVacationService = async (vacationData) => {
  const { record_date, worker_id, vacation_type_id } = vacationData;

  if (!record_date || !worker_id || !vacation_type_id) {
    throw new ValidationError('필수 필드가 누락되었습니다', {
      required: ['record_date', 'worker_id', 'vacation_type_id'],
      received: { record_date, worker_id, vacation_type_id }
    });
  }

  logger.info('휴가 처리 요청', { record_date, worker_id, vacation_type_id });

  try {
    const result = await AttendanceModel.processVacation({
      record_date,
      worker_id,
      vacation_type_id
    });

    logger.info('휴가 처리 성공', { record_date, worker_id });
    return result;
  } catch (error) {
    logger.error('휴가 처리 실패', { record_date, worker_id, error: error.message });
    throw new DatabaseError('휴가 처리 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 초과 근무 승인
 */
const approveOvertimeService = async (overtimeData) => {
  const { record_date, worker_id, overtime_approved } = overtimeData;

  if (!record_date || !worker_id || overtime_approved === undefined) {
    throw new ValidationError('필수 필드가 누락되었습니다', {
      required: ['record_date', 'worker_id', 'overtime_approved'],
      received: { record_date, worker_id, overtime_approved }
    });
  }

  logger.info('초과 근무 승인 요청', { record_date, worker_id, overtime_approved });

  try {
    const result = await AttendanceModel.approveOvertime({
      record_date,
      worker_id,
      overtime_approved
    });

    logger.info('초과 근무 승인 처리 성공', { record_date, worker_id });
    return result;
  } catch (error) {
    logger.error('초과 근무 승인 실패', { record_date, worker_id, error: error.message });
    throw new DatabaseError('초과 근무 승인 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 근태 유형 목록 조회
 */
const getAttendanceTypesService = async () => {
  logger.info('근태 유형 목록 조회 요청');

  try {
    const types = await AttendanceModel.getAttendanceTypes();
    logger.info('근태 유형 목록 조회 성공', { count: types.length });
    return types;
  } catch (error) {
    logger.error('근태 유형 목록 조회 실패', { error: error.message });
    throw new DatabaseError('근태 유형 목록 조회 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 휴가 유형 목록 조회
 */
const getVacationTypesService = async () => {
  logger.info('휴가 유형 목록 조회 요청');

  try {
    const types = await AttendanceModel.getVacationTypes();
    logger.info('휴가 유형 목록 조회 성공', { count: types.length });
    return types;
  } catch (error) {
    logger.error('휴가 유형 목록 조회 실패', { error: error.message });
    throw new DatabaseError('휴가 유형 목록 조회 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 작업자 휴가 잔여 일수 조회
 */
const getWorkerVacationBalanceService = async (workerId) => {
  if (!workerId) {
    throw new ValidationError('작업자 ID가 필요합니다', {
      required: ['worker_id'],
      received: { workerId }
    });
  }

  logger.info('휴가 잔여 일수 조회 요청', { workerId });

  try {
    const balance = await AttendanceModel.getWorkerVacationBalance(workerId);
    logger.info('휴가 잔여 일수 조회 성공', { workerId });
    return balance;
  } catch (error) {
    logger.error('휴가 잔여 일수 조회 실패', { workerId, error: error.message });
    throw new DatabaseError('휴가 잔여 일수 조회 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 월별 근태 통계 조회
 */
const getMonthlyAttendanceStatsService = async (year, month, workerId = null) => {
  if (!year || !month) {
    throw new ValidationError('연도와 월이 필요합니다', {
      required: ['year', 'month'],
      received: { year, month }
    });
  }

  logger.info('월별 근태 통계 조회 요청', { year, month, workerId });

  try {
    const stats = await AttendanceModel.getMonthlyAttendanceStats(year, month, workerId);
    logger.info('월별 근태 통계 조회 성공', { year, month });
    return stats;
  } catch (error) {
    logger.error('월별 근태 통계 조회 실패', { year, month, error: error.message });
    throw new DatabaseError('월별 근태 통계 조회 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 출근 체크 목록 조회 (휴가 정보 포함)
 */
const getCheckinListService = async (date) => {
  if (!date) {
    throw new ValidationError('날짜가 필요합니다', {
      required: ['date'],
      received: { date }
    });
  }

  logger.info('출근 체크 목록 조회 요청', { date });

  try {
    const checkinList = await AttendanceModel.getCheckinList(date);
    logger.info('출근 체크 목록 조회 성공', { date, count: checkinList.length });
    return checkinList;
  } catch (error) {
    logger.error('출근 체크 목록 조회 실패', { date, error: error.message });
    throw new DatabaseError('출근 체크 목록 조회 중 데이터베이스 오류가 발생했습니다');
  }
};

/**
 * 출근 체크 일괄 저장
 */
const saveCheckinsService = async (date, checkins) => {
  if (!date || !checkins || !Array.isArray(checkins)) {
    throw new ValidationError('날짜와 출근 체크 목록이 필요합니다', {
      required: ['date', 'checkins'],
      received: { date, checkins: checkins ? `Array[${checkins.length}]` : null }
    });
  }

  logger.info('출근 체크 일괄 저장 요청', { date, count: checkins.length });

  try {
    const results = [];

    for (const checkin of checkins) {
      const { worker_id, is_present } = checkin;

      if (!worker_id || is_present === undefined) {
        logger.warn('출근 체크 데이터 누락', { checkin });
        continue;
      }

      const result = await AttendanceModel.upsertCheckin({
        worker_id,
        record_date: date,
        is_present
      });

      results.push({
        worker_id,
        record_id: result,
        is_present
      });
    }

    logger.info('출근 체크 일괄 저장 성공', { date, saved: results.length });
    return {
      saved_count: results.length,
      results
    };
  } catch (error) {
    logger.error('출근 체크 일괄 저장 실패', { date, error: error.message });
    throw new DatabaseError('출근 체크 저장 중 데이터베이스 오류가 발생했습니다');
  }
};

module.exports = {
  getDailyAttendanceStatusService,
  getDailyAttendanceRecordsService,
  upsertAttendanceRecordService,
  processVacationService,
  approveOvertimeService,
  getAttendanceTypesService,
  getVacationTypesService,
  getWorkerVacationBalanceService,
  getMonthlyAttendanceStatsService,
  getCheckinListService,
  saveCheckinsService
};