/*
 * MosP - Mind Open Source Project         http://www.mosp.jp/
 * Copyright (C) 1987-2008 MIND Co., Ltd.  http://www.e-mind.co.jp/
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
package jp.mosp.kintai.action;

import java.sql.SQLException;

import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.TreeMap;

import java.util.List;
import java.util.Map;

import jp.mosp.common.CommonConst;
import jp.mosp.common.JapanHolidayUtility;
import jp.mosp.common.action.MosPAction;
import jp.mosp.common.common.MospConst;
import jp.mosp.common.common.MospUtility;
import jp.mosp.common.common.VoInterface;

import jp.mosp.human.dto.MKihonDto;

import jp.mosp.kintai.dao.CmRotationDao;
import jp.mosp.kintai.dao.MScheduleDao;
import jp.mosp.kintai.dao.MSyukkinboDao;
import jp.mosp.kintai.dto.CmRotationDto;
import jp.mosp.kintai.dto.MScheduleDto;
import jp.mosp.kintai.dto.MSyukkinboDto;
import jp.mosp.kintai.vo.AttendanceMenuVo;
import jp.mosp.kintai.vo.ScheduleMenuVo;

import jp.mosp.payroll.dto.CompileAmendmentDto;
import jp.mosp.payroll.dto.MKintaiDto;

import jp.mosp.system.dto.MWorkTypeDto;
import jp.mosp.system.dto.MYakusyokuDto;

public abstract class AttendanceTotalAction extends MosPAction {

	// フィールド
	protected String	startDate;
	protected String	endDate;

	protected int 		autoCalc		= 0;
	protected int		lateNightStart 	= 0;
	protected int		lateNightEnd 	= 0;
	protected int		startTime		= 0;
	protected int		quitTime 		= 0;
	protected int		workTime 		= 0;
	protected int		breakTime 		= 0;
	protected int		overStart	 	= 0;
	protected int		overBreak	 	= 0;
	protected int		allHoliday	 	= 0;
	protected int		halfHoliday	 	= 0;

	protected int		late = 0;
	protected int		work = 0;
	protected int		leave = 0;
	protected int		over = 0;
	protected int		interval = 0;
	protected int		latenight = 0;
	protected int		holidaywork = 0;

	protected int		holidayTime 	= 0;
	protected int		inputUnit 		= 1;

	protected boolean isAutoCalc;

	protected double	hoursPerDay		= 0;
	protected double	prescribedDays	= 0;
	protected double	prescribedHours	= 0;

	protected List<MSyukkinboDto>	attendanceList;
	protected List<MScheduleDto> 	scheduleList;

	// リスト
	protected Map<String, MWorkTypeDto> workTypeMap;

	protected String[][] aryHolidayReason;
	protected String[][] aryApprovalReason;

	// 日集計データ
	protected String[][] aryAttendance;
	// 月集計データ
	protected String[][] aryAttendanceCompile;

	/*						
	 *  	2009/04/21	m.yoshida	追加
	 */
	protected MScheduleDao 	scheduleDao;
	protected MSyukkinboDao 	syukkinboDao;

	/**
	 * 予定簿用DAO準備
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @throws Exception
	 */
	protected void prepareMScheduleDao() throws Exception {
		// DAO準備
		if (scheduleDao !=null) {
			return;
		}
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		scheduleDao = new MScheduleDao();
		scheduleDao.initDao(cfg, cmd, aspUser, user, conn);
	}

	/**
	 * 出勤簿用DAO準備
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @throws Exception
	 */
	protected void prepareMSyukkinboDao() throws Exception {
		// DAO準備
		if (syukkinboDao !=null) {
			return;
		}
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		syukkinboDao = new MSyukkinboDao();
		syukkinboDao.initDao(cfg, cmd, aspUser, user, conn);
	}

	/**
	 * 予定簿対象日取得
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kcode			対象社員コード
	 * @param targetDate	対象年月日
	 * @return dto 対象DTO
	 * @throws Exception
	 */
	protected MScheduleDto getScheduleInfo(String kcode, String targetDate) throws Exception {
		// 予定簿用DAO準備
		prepareMScheduleDao();
		MScheduleDto dto = scheduleDao.findForKey(kcode, targetDate);
		return dto;
	}

	/**
	 * 予定簿対象日取得
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kcode			対象社員コード
	 * @param targetDate	対象年月日
	 * @return dto 対象DTO
	 * @throws Exception
	 */
	protected MScheduleDto getScheduleInfo(String kcode, Date targetDate) throws Exception {
		// 予定簿用DAO準備
		prepareMScheduleDao();
		MScheduleDto dto = scheduleDao.findForKey(kcode, util.convDateFormatted(targetDate));
		return dto;
	}

	/**
	 * 予定簿対象日行ロック
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param dto		対象DTO
	 * @throws Exception
	 */
	protected void lockScheduleInfo(MScheduleDto dto) throws Exception {
		// 予定簿用DAO準備
		prepareMScheduleDao();
		scheduleDao.findForUpdate(dto.getKCode(), dto.getHizuke());
	}

	/**
	 * 出勤簿対象日取得
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kcode			対象社員コード
	 * @param targetDate	対象年月日(yyyy/MM/dd)
	 * @return dto 対象DTO
	 * @throws Exception
	 */
	protected MSyukkinboDto getSyukkinboInfo(String kcode, String targetDate) throws Exception {
		// 出勤簿用DAO準備
		prepareMSyukkinboDao();
		MSyukkinboDto dto = syukkinboDao.findForKey(kcode, targetDate);
		return dto;
	}

	/**
	 * 出勤簿対象日取得
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kcode			対象社員コード
	 * @param targetDate	対象年月日
	 * @return dto 対象DTO
	 * @throws Exception
	 */
	protected MSyukkinboDto getSyukkinboInfo(String kcode, Date targetDate) throws Exception {
		// 出勤簿用DAO準備
		prepareMSyukkinboDao();
		MSyukkinboDto dto = syukkinboDao.findForKey(kcode, util.convDateFormatted(targetDate));
		return dto;
	}

	/**
	 * 出勤簿対象日行ロック
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param dto		対象DTO
	 * @throws Exception
	 */
	protected void lockSyukkinboInfo(MSyukkinboDto dto) throws Exception {
		// 出勤簿用DAO準備
		prepareMSyukkinboDao();
		syukkinboDao.findForUpdate(dto.getKCode(), dto.getHizuke());
	}

	/**
	 * 出勤簿対象日（行ロック）取得
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日(yyyy/MM/dd)
	 * @return dto 対象DTO(行ロック済み)
	 * @throws Exception
	 */
	protected MSyukkinboDto getSyukkinboInfo(String kCode, String targetDate, boolean isUpdate) throws Exception {
		// 出勤簿用DAO準備
		prepareMSyukkinboDao();
		if (isUpdate) {
			return syukkinboDao.findForUpdate(kCode, targetDate);
		}
		return getSyukkinboInfo(kCode, targetDate);
	}

	/**
	 * 出勤簿対象日（行ロック）取得
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日
	 * @return dto 対象DTO(行ロック済み)
	 * @throws Exception
	 */
	protected MSyukkinboDto getSyukkinboInfo(String kCode, Date targetDate, boolean isUpdate) throws Exception {
		// 出勤簿用DAO準備
		prepareMSyukkinboDao();
		if (isUpdate) {
			return syukkinboDao.findForUpdate(kCode, util.convDateFormatted(targetDate));
		}
		return getSyukkinboInfo(kCode, targetDate);
	}

	/**
	 * 勤怠一覧データ
	 * @param kCode		対象社員コード
	 * @throws Exception
	 */
	protected void getAttendanceList(String kCode) throws Exception {
		// 出勤簿用DAO準備 
		prepareMSyukkinboDao();
		// 月一覧の取得
		attendanceList	= syukkinboDao.findForAttendanceList(kCode, startDate, endDate);
	}

	/**
	 * 勤怠月一覧データ取得
	 * @param kCode       対象社員コード
	 * @param targetMonth 対象月
	 * @throws Exception
	 */
	protected void getAttendanceList(String kCode, Date targetMonth) throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 検索範囲取得
		startDate = MospUtility.getDateString(getStartDate(targetMonth), CommonConst.FORMAT_DATE);
		endDate   = MospUtility.getDateString(getEndDate(targetMonth), CommonConst.FORMAT_DATE);
		// 検索
		getAttendanceList(kCode);
	}

	/**
	 * 勤怠月一覧データ取得
	 * @param kCode 対象社員コード
	 * @param year  対象年
	 * @param month 対象月
	 * @throws Exception
	 */
	protected void getAttendanceList(String kCode, String year, String month) throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 検索範囲取得
		startDate = MospUtility.getDateString(util.getFirstDateOfMonth(year, month), CommonConst.FORMAT_DATE);
		endDate   = MospUtility.getDateString(util.getLastDateOfMonth(year, month), CommonConst.FORMAT_DATE);
		// 検索
		getAttendanceList(kCode);
	}

	/**
	 * 勤怠月一覧データ取得（表示用）
	 * <p>2009/01/20	m.yoshida	追加</p>
	 * @param kCode
	 * @param targetDate
	 * @throws Exception
	 */
	protected void getAttendanceListForView(String kCode, Date targetDate) throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 検索範囲取得
		startDate = MospUtility.getDateString(getStartDateForList(targetDate), CommonConst.FORMAT_DATE);
		endDate   = MospUtility.getDateString(getEndDateForList(targetDate), CommonConst.FORMAT_DATE);
		// 検索
		getAttendanceList(kCode);
	}

	/**
	 * 勤怠日データ取得
	 * @param kCode       対象社員コード
	 * @param targetDay 対象日
	 * @throws Exception
	 */
	protected void getAttendanceDay(String kCode, Date targetDay) throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 検索範囲取得
		String attendanceDate = MospUtility.getDateString(targetDay, CommonConst.FORMAT_DATE);
		// 出勤簿用DAO準備 
		prepareMSyukkinboDao();
		// 月一覧の取得
		attendanceList	= syukkinboDao.findForCondition(kCode, attendanceDate);
		// 勤怠情報設定
		setHours();	
	}

	/**
	 * 日集計データ時間設定
	 * @throws Exception 
	 */
	protected void setHours() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 勤怠情報設定
		setCalcParam();
		// 労働時間設定
		setPrescribedHours();
		// 勤務形態マスタ設定
		setWorkTypeMap();
	}

	/**
	 * 日集計データ配列作成
	 * @throws Exception
	 */
	protected void makeAttendanceArray() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// データ数取得
		Calendar cal = Calendar.getInstance();
		cal.setTime(MospUtility.getDate(startDate));
		int count = 0;
		while (MospUtility.getDate(endDate).compareTo(cal.getTime()) >= 0) {
			cal.add(Calendar.DAY_OF_MONTH, 1);
			count++;
		}
		// 配列初期化
		aryAttendance = new String[count][40];
		for (int i = 0; i < aryAttendance.length; i++) {
			for (int j = 0; j < aryAttendance[i].length; j++) {
				aryAttendance[i][j] = "";
			}
		}
		// 日付設定
		cal.setTime(MospUtility.getDate(startDate));
		for (int i = 0; i < aryAttendance.length; i++) {
			// 日付（検索用）
			aryAttendance[i][0] = MospUtility.getDateString(cal.getTime(), CommonConst.FORMAT_DATE);
			// 日付
			aryAttendance[i][1] = String.valueOf(MospUtility.getMonth(cal.getTime()))
			+ CommonConst.SEPARATOR_DATE
			+ String.valueOf(cal.get(Calendar.DAY_OF_MONTH));
			// 曜日
			aryAttendance[i][2] = getDayOfWeek(cal.get(Calendar.DAY_OF_WEEK));
			// 備考（祝祭日、半休）
			StringBuffer remark = new StringBuffer();
			String holidayName = getPublicHolidayName(cal.getTime());
			if (holidayName.length() != 0) {
				remark.append(holidayName);
				remark.append(CommonConst.NAM_COMMON_HALF_KANA_SPACE);
			}
			aryAttendance[i][16] = remark.toString();
			cal.add(Calendar.DAY_OF_MONTH, 1);
		}
		// データの設定
		Iterator<MSyukkinboDto> it = attendanceList.iterator();
		while (it.hasNext()) {
			cal.setTime(MospUtility.getDate(startDate));
			MSyukkinboDto dto = it.next();
			Date attendanceDate = MospUtility.getDate(dto.getHizuke());
			for (int i = 0; i < aryAttendance.length; i++) {
				if (attendanceDate.compareTo(cal.getTime()) == 0) {
					// 勤務形態
					String kinmu = "";
					// 出勤の場合
					if (isAvailableWorkType(dto)) {
						kinmu = workTypeMap.get(dto.getKinmu()).getShiftName();
						// 出勤時刻
						aryAttendance[i][4 ] = dto.getSyJikoku();
						// 退勤時刻
						aryAttendance[i][5 ] = dto.getTaJikoku();
						// 勤務時間
						aryAttendance[i][6 ] = getHourString(util.convIntegerTimeToDoubleTime(dto.getKinmuJi()));
						// 休憩時間
						aryAttendance[i][7 ] = getHourString(util.convIntegerTimeToDoubleTime(dto.getKyukeiJi()));
						// 遅刻時間
						aryAttendance[i][8 ] = getHourString(util.convIntegerTimeToDoubleTime(dto.getTiJikan()));
						// 早退時間
						aryAttendance[i][9 ] = getHourString(util.convIntegerTimeToDoubleTime(dto.getSoJikan()));
						// 残業時間
						aryAttendance[i][10] = getHourString(util.convIntegerTimeToDoubleTime(dto.getZaJikan()));
						// 休出時間
						aryAttendance[i][11] = getHourString(util.convIntegerTimeToDoubleTime(dto.getKsJikan()));
						// 深夜時間
						aryAttendance[i][12] = getHourString(util.convIntegerTimeToDoubleTime(dto.getSnJikan()));
					} else if (isWeekHoliday(dto)) {
						kinmu = CommonConst.ATTENDANCE_TYPE_WEEK_HOLIDAY;
					} else {
						for (int k = 0; k < aryHolidayReason.length; k++) {
							if (aryHolidayReason[k][0].equals(dto.getKKRiyuu())) {
								kinmu = aryHolidayReason[k][1];
							}
						}
					}
					aryAttendance[i][3 ] = kinmu;
					// 一次承認、二次承認
					String[] result = setApproval(dto.getSnRiyuu());
					aryAttendance[i][13] = result[0];
					aryAttendance[i][14] = result[1];
					// 手当等
					StringBuffer sb = new StringBuffer();
					sb.append(dto.getSyokuji());
					sb.append(CommonConst.SEPARATOR_DATE);
					sb.append(dto.getCyoku1());
					sb.append(dto.getCyoku2());
					sb.append(dto.getCyoku3());
					sb.append(CommonConst.SEPARATOR_DATE);
					sb.append(dto.getHoka1());
					sb.append(dto.getHoka2());
					sb.append(dto.getHoka3());
					sb.append(dto.getHoka4());
					sb.append(dto.getHoka5());
					aryAttendance[i][15] = sb.toString();
					// 半休
					if (isQuitHalfHoliday(dto) || isQuitHalfHoliday(dto)) {
						aryAttendance[i][16] += CommonConst.NAM_VACATION_LEAVE_HALF + CommonConst.NAM_COMMON_HALF_KANA_SPACE;
					}
					if (isWorkOnHoliday(dto)) {
						aryAttendance[i][16] += CommonConst.NAM_WORK_ON_HOLIDAY + CommonConst.NAM_COMMON_HALF_KANA_SPACE;		
					}
					break;
				}
				cal.add(Calendar.DAY_OF_MONTH, 1);
			}
		}
	}

	/**
	 * 月集計
	 * @throws Exception 
	 */
	protected void totalAttendanceDaily() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// データ数取得
		Calendar cal = Calendar.getInstance();
		cal.setTime(MospUtility.getDate(startDate));
		int count = 0;
		while (MospUtility.getDate(endDate).compareTo(cal.getTime()) >= 0) {
			cal.add(Calendar.DAY_OF_MONTH, 1);
			count++;
		}
		// 配列の初期化
		aryAttendanceCompile = new String[18][2];
		// 変数宣言、変数の初期化
		// 勤務時間計
		int totalWork = 0;
		// 休憩時間計
		int totalInterbal = 0;
		// 遅刻時間計
		int totalLate = 0;
		// 早退時間計
		int totalLeave = 0;
		// 残業時間計
		int totalOver = 0;
		// 休出時間計
		int totalHolidayWork = 0;
		// 深夜時間計
		int totalLateNight = 0;
		// 出勤日数計
		int totalWorkDays = 0;
		// 有休日数計
		double totalPaidHoliday = 0;
		// 特別休暇計
		int totalParticularHoliday = 0;
		// 欠勤日数計
		int totalAbsence = 0;
		// 傷病休暇計
		int totalMedicalLeave = 0;
		// 代休日数計
		int totalCompensationDay =0;
		// 振替休暇計
		int totalTransfer = 0;
		// 其他休暇計
		int totalOther = 0;
		// 遅刻早退数
		int leaveAndLate = 0;
		// 手当
		int syokuji = 0;
		int cyoku1 = 0;
		int cyoku2 = 0;
		int cyoku3 = 0;
		int hoka1 = 0;
		int hoka2 = 0;
		int hoka3 = 0;
		int hoka4 = 0;
		int hoka5 = 0;
		// 日集計データ取得
		Iterator<MSyukkinboDto> it = attendanceList.iterator();
		// 集計開始
		while (it.hasNext()) {
			cal.setTime(MospUtility.getDate(startDate));
			MSyukkinboDto dto = it.next();
			Date attendanceDate = MospUtility.getDate(dto.getHizuke());
			for (int i = 0; i < count; i++) {
				if (attendanceDate.compareTo(cal.getTime()) == 0) {
					// 勤怠項目
					if (isAvailableWorkType(dto)) {
						// 勤務時間
						totalWork += dto.getKinmuJi();
						// 休憩時間
						totalInterbal += dto.getKyukeiJi();
						// 遅刻時間
						totalLate += dto.getTiJikan();
						// 早退時間
						totalLeave += dto.getSoJikan();
						// 残業時間
						totalOver += dto.getZaJikan();
						// 休出時間
						totalHolidayWork += dto.getKsJikan();
						// 深夜時間
						totalLateNight += dto.getSnJikan();
						// 出勤日数
						if (dto.getKinmuJi() > 0) {
							totalWorkDays++;
						}
						// 遅刻早退数
						if (dto.getTiJikan() > 0 || dto.getSoJikan() > 0) {
							leaveAndLate++;
						}
						// 手当
						syokuji += dto.getSyokuji();
						cyoku1 	+= dto.getCyoku1();
						cyoku2 	+= dto.getCyoku2();
						cyoku3 	+= dto.getCyoku3();
						hoka1 	+= dto.getHoka1();
						hoka2 	+= dto.getHoka2();
						hoka3 	+= dto.getHoka3();
						hoka4 	+= dto.getHoka4();
						hoka5 	+= dto.getHoka5();
						// 半休
						if (isQuitHalfHoliday(dto) || isQuitHalfHoliday(dto)) {
							totalPaidHoliday += 0.5;
						}
					} else {
						// 休暇項目
						if (!dto.getKKRiyuu().equals("")) {
							if (dto.getKKRiyuu().equals(aryHolidayReason[0][0])) {
								// 有給休暇（m_code, 休暇理由, tcode="0"）
								totalPaidHoliday++;
							} else if (dto.getKKRiyuu().equals(aryHolidayReason[1][0])) {
								// 特別休暇（m_code, 休暇理由, tcode="1"）
								totalParticularHoliday++;
							} else if (dto.getKKRiyuu().equals(aryHolidayReason[2][0])) {
								// 欠勤日数（m_code, 休暇理由, tcode="2"）
								totalAbsence++;
							} else if (dto.getKKRiyuu().equals(aryHolidayReason[3][0])) {
								// 傷病休暇（m_code, 休暇理由, tcode="3"）
								totalMedicalLeave++;
							} else if (dto.getKKRiyuu().equals(aryHolidayReason[4][0])) {
								// 代休日数（m_code, 休暇理由, tcode="4"）
								totalCompensationDay++;
							} else if (dto.getKKRiyuu().equals(aryHolidayReason[5][0])) {
								// 振替休暇（m_code, 休暇理由, tcode="5"）
								totalTransfer++;
							} else {
								// 其他休暇（m_code, 休暇理由, tcode="6"より上）
								totalOther++;
							}
						}
					}
				}
				cal.add(Calendar.DAY_OF_MONTH, 1);
			}
		}
		// 配列
		// 勤務時間合計
		aryAttendanceCompile[0][0] = CommonConst.NAM_WORKING;
		aryAttendanceCompile[0][1] = getHourString(util.convIntegerTimeToDoubleTime(totalWork));
		// 休憩時間合計
		aryAttendanceCompile[1][0] = CommonConst.NAM_INTERVAL_TIME;
		aryAttendanceCompile[1][1] = getHourString(util.convIntegerTimeToDoubleTime(totalInterbal));
		// 遅刻時間合計
		aryAttendanceCompile[2][0] = CommonConst.NAM_ARRIVE_LATE;
		aryAttendanceCompile[2][1] = getHourString(util.convIntegerTimeToDoubleTime(totalLate));
		// 早退時間合計
		aryAttendanceCompile[3][0] = CommonConst.NAM_LEAVE_EARLY;
		aryAttendanceCompile[3][1] = getHourString(util.convIntegerTimeToDoubleTime(totalLeave));
		// 残業時間合計
		aryAttendanceCompile[4][0] = CommonConst.NAM_OVERTIME;
		aryAttendanceCompile[4][1] = getHourString(util.convIntegerTimeToDoubleTime(totalOver));
		// 休出時間合計
		aryAttendanceCompile[5][0] = CommonConst.NAM_WORK_ON_HOLIDAY;
		aryAttendanceCompile[5][1] = getHourString(util.convIntegerTimeToDoubleTime(totalHolidayWork));
		// 深夜時間合計
		aryAttendanceCompile[6][0] = CommonConst.NAM_LATE_NIGHT;
		aryAttendanceCompile[6][1] = getHourString(util.convIntegerTimeToDoubleTime(totalLateNight));
		// 出勤日数
		aryAttendanceCompile[7][0] = CommonConst.NAM_PRESENCE;
		aryAttendanceCompile[7][1] = String.valueOf(totalWorkDays);
		// 有給休暇日数
		aryAttendanceCompile[8][0] = aryHolidayReason[0][1];
		aryAttendanceCompile[8][1] = String.valueOf(totalPaidHoliday);
		// 特別休暇日数
		aryAttendanceCompile[9][0] = aryHolidayReason[1][1];
		aryAttendanceCompile[9][1] = String.valueOf(totalParticularHoliday);
		// 欠勤休暇日数
		aryAttendanceCompile[10][0] = aryHolidayReason[2][1];
		aryAttendanceCompile[10][1] = String.valueOf(totalAbsence);
		// 傷病休暇日数
		aryAttendanceCompile[11][0] = aryHolidayReason[3][1];
		aryAttendanceCompile[11][1] = String.valueOf(totalMedicalLeave);
		// 代休日数
		aryAttendanceCompile[12][0] = aryHolidayReason[4][1];
		aryAttendanceCompile[12][1] = String.valueOf(totalCompensationDay);
		// 振替休暇日数
		aryAttendanceCompile[13][0] = aryHolidayReason[5][1];
		aryAttendanceCompile[13][1] = String.valueOf(totalTransfer);
		// 其他休暇日数
		aryAttendanceCompile[14][0] = CommonConst.NAM_OTHER_SHORT;
		aryAttendanceCompile[14][1] = String.valueOf(totalOther);
		// 遅刻早退数
		aryAttendanceCompile[15][0] = CommonConst.NAM_LATE_AND_LEAVE_EARLY;
		aryAttendanceCompile[15][1] = String.valueOf(leaveAndLate);
		// 手当
		StringBuffer allowance = new StringBuffer();
		allowance.append(syokuji);
		allowance.append(CommonConst.SEPARATOR_DATE);
		allowance.append(cyoku1);
		allowance.append(cyoku2);
		allowance.append(cyoku3);
		allowance.append(CommonConst.SEPARATOR_DATE);
		allowance.append(hoka1);
		allowance.append(hoka2);
		allowance.append(hoka3);
		allowance.append(hoka4);
		allowance.append(hoka5);
		aryAttendanceCompile[16][0] = CommonConst.NAM_ALLOWANCE;
		aryAttendanceCompile[16][1] = allowance.toString();
		// 皆勤（欠勤、特別休暇、傷病、遅刻早退数の合計）
		if ((totalAbsence + totalParticularHoliday + totalMedicalLeave + leaveAndLate) == 0
				&& totalWorkDays != 0) {
			aryAttendanceCompile[17][0] = CommonConst.NAM_PERFECT_ATTENDANCE;
			aryAttendanceCompile[17][1] = CommonConst.NAM_PERFECT_ATTENDANCE;
		} else {
			aryAttendanceCompile[17][0] = CommonConst.NAM_PERFECT_ATTENDANCE;
			aryAttendanceCompile[17][1] = "";			
		}
	}

	/**
	 * 形態マスタ設定
	 * @throws SQLException 
	 * @throws ClassNotFoundException 
	 * @throws NoSuchFieldException 
	 * @throws IllegalAccessException 
	 */
	protected void setWorkTypeMap() throws ClassNotFoundException, SQLException, IllegalAccessException, NoSuchFieldException {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 取得済確認
		if (workTypeMap != null) {
			return;
		}
		// Mapの作成
		workTypeMap = getWorkTypeMap();
	}

	/**
	 * 1日所定労働時間取得
	 * @throws Exception 
	 */
	protected void setPrescribedHours() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 取得済確認
		if (hoursPerDay != 0) {
			return;
		}
		// M_CODEから値を取得
		String[] aryConf = getMosPCode(CommonConst.TID_STATUTORY, CommonConst.TCD_STATUTORY_HOUR);
		// 値の設定
		hoursPerDay = Double.parseDouble(aryConf[2]);
	}

	/**
	 * 深夜時間取得
	 * @throws Exception 
	 */
	private void setLateNightTime() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 取得済確認
		if (lateNightStart != 0) {
			return;
		}
		// M_CODEから値を取得
		String[] aryConf = getMosPCode(CommonConst.TID_WORK_SYSTEM, CommonConst.TCD_LATE_NIGHT);
		// 値の設定
		lateNightStart = Integer.parseInt(aryConf[2].substring(0, 2)) * 60 
		+ Integer.parseInt(aryConf[2].substring(3, 5));
		lateNightEnd   = lateNightStart 
		+ Integer.parseInt(aryConf[2].substring(6, 8)) * 60
		+ Integer.parseInt(aryConf[2].substring(9, 11));
	}

	/**
	 * 月間所定労働日数・時間取得
	 * @throws Exception 
	 */
	private void setPrescribedCalendar() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 取得済確認
		if (prescribedDays != 0) {
			return;
		}
		if (prescribedHours != 0) {
			return;
		}
		// 月間所定労働日数
		String[] aryConfDays = getMosPCode(CommonConst.TID_STATUTORY_MONTH, CommonConst.TCD_STATUTORY_DAYS);
		prescribedDays = Double.parseDouble(aryConfDays[2]);
		// 月間所定労働時間数
		String[] aryConfHours = getMosPCode(CommonConst.TID_STATUTORY_MONTH, CommonConst.TCD_STATUTORY_HOUR);
		prescribedHours = Double.parseDouble(aryConfHours[2]);
	}

	/**
	 * 自動計算フラグ取得
	 * @throws Exception
	 */
	private void setAutoCalc() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 自動計算フラグ取得
		String[] aryAutoCalc = getMosPCode(CommonConst.TID_WORK_SYSTEM, CommonConst.TCD_AUTOMATIC_CALCULATION);
		autoCalc = Integer.parseInt(aryAutoCalc[2]);
		if (autoCalc == 0) {
			isAutoCalc = true;
		} else {
			isAutoCalc = false;
		}
	}

	/**
	 * 休暇時間取得
	 * @throws Exception
	 */
	private void setHolidayTimes() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		String[] aryHolidayTimes = getMosPCode(CommonConst.TID_WORK_SYSTEM, CommonConst.TCD_HOLIDAY_HOURS);
		allHoliday = Integer.parseInt(aryHolidayTimes[2].substring(0, 2)) * 60 
		+ Integer.parseInt(aryHolidayTimes[2].substring(3, 5));
		halfHoliday = Integer.parseInt(aryHolidayTimes[2].substring(6, 8)) * 60 
		+ Integer.parseInt(aryHolidayTimes[2].substring(9, 11));
	}

	/**
	 * 勤務形態別情報設定
	 * @param shiftcode
	 * @throws Exception
	 */
	protected void getWorkTypeInfo(String shiftcode) throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 勤務形態情報取得
		MWorkTypeDto dto = workTypeMap.get(shiftcode);
		startTime 	= dto.getStartTime();
		quitTime 	= dto.getQuitTime();
		workTime 	= dto.getWorkTime();
		breakTime	= dto.getBreakTime();
		overStart	= dto.getOverStart();
		overBreak	= dto.getOverBreak();
	}

	/**
	 * 集計基本設定
	 * @throws Exception
	 */
	protected void setCalcParam() throws Exception {
		// 自動計算設定
		setAutoCalc();
		// 入力単位時間
		inputUnit = Integer.parseInt(getMosPCode(CommonConst.TID_INPUT_UNIT_TIMES, CommonConst.TCD_MINUTES)[2]);
		// 深夜時間設定
		setLateNightTime();
		// 休暇時間設定
		setHolidayTimes();
		// 月間所定労働日数・時間設定
		setPrescribedCalendar();
		// 休暇理由
		aryHolidayReason = getMosPCodeArray(CommonConst.TID_LEAVE_REASON);
		// 承認理由
		aryApprovalReason = getMosPCodeArray(CommonConst.TID_APPROVAL_REASON);
	}

	/**
	 * 出勤項目の計算
	 * @param start 出勤時刻(int)
	 * @param isStartHalf 出勤時半休の場合 true
	 * @param isHolidayWork 休出の場合true
	 */
	protected void getCalcStartTime(int start, boolean isStartHalf, boolean isHolidayWork) {
		if (isStartHalf | isHolidayWork) {
			late = 0;
		} else {
			late = setLateTimes(start);
		}
	}

	/**
	 * 遅刻時間計算
	 * @param start 出勤時刻
	 * @return	int	遅刻時間
	 */
	private int setLateTimes(int start) {
		// 出勤時刻 - 標準出勤時刻
		int latemin = start - startTime;
		// 遅刻のときは調整計算(単位時間を加算)5分の場合計算結果が0分になるので最低でも単位時間とする
		if ((latemin < inputUnit) && (startTime < start)) {
			latemin = inputUnit;
		}
		if (latemin > 0) {
			// 丸め
			latemin -= latemin%inputUnit;
		}
		if (latemin < 0) {
			latemin = 0;
		}
		return latemin;
	}

	/**
	 * 退勤項目の計算
	 * @param start 出勤時刻
	 * @param quit 退勤時刻
	 * @param isHalf 出勤時半休、退勤時半休の場合true
	 */
	protected void getCalcQuitTime(int start, int quit, boolean isHalf) {
		// 勤務時間
		work 		= setWorkTimes(start, quit);
		leave 		= setLeaveEarlyTimes(quit);
		if (isHalf) {
			leave = 0;
		}
		over 		= setOverTimes(isHalf);
		interval 	= setIntervalTimes();
		latenight	= setLateNightTimes(quit);
		holidaywork	= setHolidayWork();
	}

	/**
	 * 勤務時間計算
	 * @param start
	 * @param quit
	 * @return	workmin
	 */
	private int setWorkTimes(int start, int quit) {
		// 退社時刻 - 出勤時刻		
		int workmin = quit - start;
		// 丸め
		workmin -= workmin%inputUnit;
		return workmin;
	}

	/**
	 * 早退時間計算
	 * @return	leavemin
	 */
	private int setLeaveEarlyTimes(int quit) {
		// 標準退社時刻 - 退社時刻
		int leavemin = quitTime - quit;
		// 勤務時間 < 標準勤務時間
		if (work < workTime) {
			// 丸め
			leavemin -= leavemin%inputUnit;
		}
		if (leavemin < 0) {
			leavemin = 0;
		}
		return leavemin;
	}

	/**
	 * 残業時間計算
	 * @param isHalf 出勤時半休、退勤時半休の場合true
	 * @return	overmin
	 */
	private int setOverTimes(boolean isHalf) {
		// 遅刻時間 + 勤務時間
		int worktimes = late + work;
		// 残業時間
		int overmin = 0;
		// 半休調整
		if (isHalf) {
			worktimes -= halfHoliday;
		}
		// 勤務対象時間 > 標準残業計算開始時間
		if (worktimes > overStart) {
			// 勤務対象時間 - 標準勤務時間 - 残業休憩
			overmin = worktimes - workTime - overBreak;
			if (overmin < 0) {
				overmin = 0;
			}
		}
		return overmin;
	}

	/**
	 * 休憩時間計算
	 * @return	intervalmin
	 */
	private int setIntervalTimes() {
		int intervalmin = 0;
		// 標準休憩  5時間以上
		if (work > 300) {
			intervalmin = breakTime;
		}
		// 残業休憩
		if (over > 0) {
			intervalmin += overBreak;
		}
		return intervalmin;
	}

	/**
	 * 深夜時間計算
	 * @return	latenightmin
	 */
	private int setLateNightTimes(int quit) {
		// 退社時刻 - 標準深夜開始時刻
		int latenightmin = quit - lateNightStart;
		// 丸め
		latenightmin -= latenightmin%inputUnit;
		// 限度調整
		if (latenightmin > (lateNightEnd - lateNightStart)) {
			latenightmin = lateNightEnd - lateNightStart;
		}
		if (latenightmin < 0) {
			latenightmin = 0;
		}
		return latenightmin;
	}

	/**
	 * 休出時間計算
	 * @return	holiwork
	 */
	private int setHolidayWork() {
		int holiwork = work - interval;
		return holiwork;
	}

	/**
	 * 承認理由表示
	 * @param riyuu 承認理由
	 * @return	result
	 */
	protected String[] setApproval(String riyuu) {
		String[] result = new String[2];
		for (int k = 0; k < aryApprovalReason.length; k++) {
			if (isRequest(riyuu)) {
				// 申請中の場合（一次…申請中、二次…空欄）
				result[0] = aryApprovalReason[0][1];
				result[1] = "";
			} else if (is1stApproved(riyuu)) {
				// 一次承認済の場合（一次…承認済、二次申請中）
				result[0] = aryApprovalReason[1][1];
				result[1] = aryApprovalReason[0][1];
			} else if (riyuu.equals(CommonConst.NUM_ATTENDANCE_1ST_RETURNED)) {
				// 一次差戻の場合（一次…差戻、二次…空欄）
				result[0] = aryApprovalReason[2][1];
				result[1] = "";
			} else if (is2ndApproved(riyuu)) {
				// 二次承認済の場合（一次…承認済、二次承認済）
				result[0] = aryApprovalReason[1][1];
				result[1] = aryApprovalReason[3][1];
			} else if (riyuu.equals(CommonConst.NUM_ATTENDANCE_2ND_RETURNED)) {
				// 一次差戻の場合（一次…二次差戻、二次…空欄）
				result[0] = aryApprovalReason[4][1];
				result[1] = "";
			} else {
				result[0] = "";
				result[1] = "";
			}
		}
		return result;
	}

	/**
	 * 勤怠検索
	 * @throws Exception
	 */
	protected void searchAttendance() throws Exception {
		// 勤怠検索
		MSyukkinboDto dto = getSyukkinboInfo(key1, key2);
		if (dto != null) {
			if (!isHoliday(dto)) {
				// 出勤有り、退勤無し
				if (dto.getTaJikoku().equals("") && !isWeekHoliday(dto)) {
					// 退勤表示へ
					setNextCmd(AttendanceQuitCardAction.CMD_QUIT_CARD_SHOW);
				} else {
					// 出勤有り、退勤有り（週休の場合も）
					// 確認表示へ
					setNextCmd(AttendanceCheckCardAction.CMD_CHECK_CARD_SELECT);
				}				
			} else {
				// 休暇
				// 休暇表示へ
				setNextCmd(AttendanceHolidayCardAction.CMD_HOLIDAY_CARD_SELECT);		
			}
		} else {
			// 出勤表示へ
			setNextCmd(AttendanceStartCardAction.CMD_START_CARD_SHOW);
		}
		// サーブレットへ転送
		setUrl(MospConst.URL_SRV);
	}

	/**
	 * 勤怠登録パラメータ設定
	 * @param vo
	 * @throws Exception
	 */
	protected void setAttendanceInfo(AttendanceMenuVo vo) throws Exception {
		// 人事基本情報取得
		MKihonDto mKihonDto = getBasisInfo(key1);
		// AttendanceMenuVoに値をセット
		vo.setHidKCode(mKihonDto.getKCode());
		vo.setHidKName(mKihonDto.getSimei());
		vo.setHidYear(String.valueOf(MospUtility.getYear(MospUtility.getDate(key2))));
		vo.setHidMonth(String.valueOf(MospUtility.getMonth(MospUtility.getDate(key2))));
		vo.setHidDay(String.valueOf(MospUtility.getDay(MospUtility.getDate(key2))));
		vo.setHidDate(util.convStringDateFormatted(vo.getHidYear(), vo.getHidMonth(), vo.getHidDay()));
		vo.setHidSelectCmd(cmd);
		vo.setLblKCode(vo.getHidKCode());
		vo.setLblKName(vo.getHidKName());
		vo.setLblYear(vo.getHidYear());
		vo.setLblMonth(vo.getHidMonth());
		vo.setLblDay(vo.getHidDay());
	}

	/**
	 * 表示モードセット
	 * <p>[新規]、[更新]、[承認済み]</p>
	 * @param vo
	 * @param dto
	 */
	protected void setMode(AttendanceMenuVo vo, MSyukkinboDto dto) throws Exception {
		if (dto == null) {
			vo.setMode(AttendanceMenuVo.MODE_INSERT);
		} else if (isApproved(dto)) {
			vo.setMode(AttendanceMenuVo.MODE_APPROVED);
		} else {
			vo.setMode(AttendanceMenuVo.MODE_EDIT);
		}
	}

	/**
	 * 再検索用MenuVoの保存
	 * @param vo
	 */
	protected void setStoreAttendanceMenuVo(AttendanceMenuVo vo) {
		// 保存VOの破棄
		removeStoredVo(CommonConst.VO_ATTENDANCE_MENU);
		// VOの保存
		storeVo(CommonConst.VO_ATTENDANCE_MENU, vo);
	}

	/**
	 * 承認・未承認件数作成
	 * @return [0]…承認件数、[1]…未承認件数、[2]…出勤件数
	 * @throws Exception
	 */
	protected int[] makeApprovalNumber() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// データ数取得
		Calendar cal = Calendar.getInstance();
		cal.setTime(MospUtility.getDate(startDate));
		int count = 0;
		while (MospUtility.getDate(endDate).compareTo(cal.getTime()) >= 0) {
			cal.add(Calendar.DAY_OF_MONTH, 1);
			count++;
		}
		// 配列初期化
		int number[] = {0, 0, 0};
		// 日付設定
		cal.setTime(MospUtility.getDate(startDate));
		// データの設定
		Iterator<MSyukkinboDto> it = attendanceList.iterator();
		// 出勤件数
		number[2] = attendanceList.size();
		while (it.hasNext()) {
			cal.setTime(MospUtility.getDate(startDate));
			MSyukkinboDto dto = it.next();
			Date attendanceDate = MospUtility.getDate(dto.getHizuke());
			for (int i = 0; i < count; i++) {
				if (attendanceDate.compareTo(cal.getTime()) == 0) {
					// 一次承認、二次承認
					if (is2ndApproved(dto)) {
						number[0]++;
					} else {
						number[1]++;
					}
					break;
				}
				cal.add(Calendar.DAY_OF_MONTH, 1);
			}
		}
		return number;
	}

	/**
	 * 祝日名称取得
	 * <p>	2009/02/25	m.yoshida	祝日メソッド修正 </p>
	 * @param targetDate		対象年月日
	 * @return	対象年月日祝日名称
	 * @throws Exception
	 */
	protected String getPublicHolidayName(Date targetDate) throws Exception {
		String holidayName = "";
		// 対象日祝日名称取得
		String targetName = getHolidayMap(MospUtility.getYear(targetDate)).get(targetDate);
		if (targetName != null) {
			holidayName = targetName;
		}
		return holidayName;
	}

	/**
	 * 単年祝祭日配列取得
	 * @param year
	 * @return	result
	 */
	private String[][] getAryHolidaySingleYear(int year) {
		JapanHolidayUtility utl = new JapanHolidayUtility(year);
		String[][] result = utl.getArySyuku();
		return result;
	}

	/**
	 * 祝日名称マップ生成
	 * @param year			対象年
	 * @throws Exception
	 */
	private Map<Date, String> getHolidayMap(int year) throws Exception {
		Map<Date, String> holidayMap = new TreeMap<Date, String>();
		// 祝祭日、休日設定
		String[][] aryCodeHoliday = getMosPCodeArray(CommonConst.TID_HOLIDAY);
		Date holiday = null;
		for (int k = 0; k < aryCodeHoliday.length; k++) {
			// MM/DDから始まる休日への対応
			if (aryCodeHoliday[k][0].startsWith("0")
					|| aryCodeHoliday[k][0].startsWith("1")
			) {
				StringBuffer date = new StringBuffer();
				date.append(String.valueOf(year));
				date.append(CommonConst.SEPARATOR_DATE);
				date.append(aryCodeHoliday[k][0].split(CommonConst.SEPARATOR_DATE)[0]);
				date.append(CommonConst.SEPARATOR_DATE);
				date.append(aryCodeHoliday[k][0].split(CommonConst.SEPARATOR_DATE)[1]);
				holiday = MospUtility.getDate(date.toString());
			} else {
				holiday = MospUtility.getDate(aryCodeHoliday[k][0]);
			}
			holidayMap.put(holiday, aryCodeHoliday[k][1]);
		}
		// ハッピーマンデー設定
		String[][] aryJapanHoliday = getAryHolidaySingleYear(year);
		for (int i = 0; i < aryJapanHoliday.length; i++) {
			holiday = MospUtility.getDate(aryJapanHoliday[i][0]);
			if (holidayMap.get(holiday) == null) {
				holidayMap.put(holiday, aryJapanHoliday[i][1]);
			}
		}
		return holidayMap;
	}

	/**
	 * 勤怠一覧用サブタイトルコマンドの設定
	 * @param vo	対象VO
	 */
	protected void setSubTitleMenu(AttendanceMenuVo vo) {
		// 勤怠管理コマンド
		if (getStoredVo(CommonConst.VO_EMPLOYEE_ATTENDANCE_LIST) != null) {
			// 状態遷移確認
			vo.setCmdMenuButton(vo.CMD_MENU_MAMAGE);
			vo.setCmdListButton(AttendanceListAction.CMD_ATTENDANCE_LIST_RE_SEARCH);
			vo.setNamListButton(CommonConst.TTL_ATTENDANCE_LIST);
		} else {
			vo.setCmdMenuButton(vo.CMD_MENU_INPUT);
			vo.setCmdListButton(vo.CMD_MENU_INPUT);
			vo.setNamListButton(CommonConst.NAM_MENU);			
		}
	}

	/*スケジュール関連*/

	/**
	 * 予定月一覧データ
	 * @param kCode		対象社員コード
	 * @throws Exception
	 */
	protected void getScheduleList(String kCode) throws Exception {
		// 予定簿用DAO準備 
		prepareMScheduleDao();
		// 月一覧の取得
		scheduleList = scheduleDao.findForScheduleList(kCode, startDate, endDate);
	}

	/**
	 * 予定月一覧データ取得
	 * @param kCode       対象社員コード
	 * @param targetMonth 対象月
	 * @throws Exception
	 */
	protected void getScheduleList(String kCode, Date targetMonth) throws Exception {
		// 検索範囲取得
		startDate = MospUtility.getDateString(getStartDate(targetMonth), CommonConst.FORMAT_DATE);
		endDate   = MospUtility.getDateString(getEndDate(targetMonth), CommonConst.FORMAT_DATE);
		// 検索
		getScheduleList(kCode);
	}

	/**
	 * 勤怠月一覧データ取得
	 * @param kCode 対象社員コード
	 * @param year  対象年
	 * @param month 対象月
	 * @throws Exception
	 */
	protected void getScheduleList(String kCode, String year, String month) throws Exception {
		// 検索範囲取得
		startDate = MospUtility.getDateString(util.getFirstDateOfMonth(year, month), CommonConst.FORMAT_DATE);
		endDate   = MospUtility.getDateString(util.getLastDateOfMonth(year, month), CommonConst.FORMAT_DATE);
		// 検索
		getScheduleList(kCode);
	}

	/**
	 * 予定月一覧データ取得（表示用）
	 * <p>2009/01/20	m.yoshida	追加</p>
	 * @param kCode 		対象社員コード
	 * @param targetDate	対象年月日
	 * @throws Exception
	 */
	protected void getScheduleListForView(String kCode, Date targetDate) throws Exception {
		// 検索範囲取得
		startDate = MospUtility.getDateString(getStartDateForList(targetDate), CommonConst.FORMAT_DATE);
		endDate   = MospUtility.getDateString(getEndDateForList(targetDate), CommonConst.FORMAT_DATE);
		// 検索
		getScheduleList(kCode);
	}

	/**
	 * 日集計データ時間設定
	 * @throws Exception 
	 */
	protected void setScheduleHours() throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// 勤怠情報設定
		setHours();
		// 日集計データ取得
		Iterator<MScheduleDto> it = scheduleList.iterator();
		while (it.hasNext()) {
			MScheduleDto dto = it.next();
			if (isHoliday(dto)) {
				// 休暇の場合
				dto.setKKJikan(allHoliday);
			} else if (isWeekHoliday(dto)) {
				// 週休の場合
			} else {
				// 出勤の場合
				// 初期化
				late 		= 0;
				work 		= 0;
				leave 		= 0;
				over 		= 0;
				interval 	= 0;
				latenight 	= 0;
				holidaywork = 0;
				// 勤務形態から規定時刻を取得
				getWorkTypeInfo(dto.getKinmu());
				// 出勤時刻算出
				int start = util.convStringTimeToIntegerTime(dto.getSyJikoku());
				// 退勤時刻算出
				int quit = quitTime;
				if (!dto.getTaJikoku().equals("")) {
					quit = util.convStringTimeToIntegerTime(dto.getTaJikoku());
				}
				boolean shankyukbn = isStartHalfHoliday(dto);
				boolean kyusyukbn = isWorkOnHoliday(dto);
				boolean thankyukbn = isQuitHalfHoliday(dto);
				// 出勤項目の計算
				getCalcStartTime(start, shankyukbn, kyusyukbn);
				// 遅刻時間セット
				dto.setTiJikan(late);
				// 退勤項目の計算
				getCalcQuitTime(start, quit, (shankyukbn || thankyukbn));
				// 勤務時間セット
				dto.setKinmuJi(work);
				// 早退時間セット
				dto.setSoJikan(leave);
				// 残業時間セット
				dto.setZaJikan(over);
				// 休憩時間セット
				dto.setKyukeiJi(interval);
				// 深夜時間セット
				dto.setSnJikan(latenight);
				// 休出時間セット
				if (kyusyukbn) {
					dto.setKsJikan(holidaywork);
				} else {
					dto.setKsJikan(0);
				}
			}
		}
	}

	/*予定簿関連*/

	/**
	 * 選択社員人事基本情報取得
	 * @param vo
	 * @throws Exception
	 */
	protected void setSelectBasicInfo(ScheduleMenuVo vo) throws Exception {
		// 人事基本情報の取得
		MKihonDto mKihonDto = getBasisInfo(vo.getSelectKCode());
		// 選択情報の設定
		vo.setSelectKName(mKihonDto.getSimei());
		vo.setSelectSectionName(util.getCodeName(mKihonDto.getSCode(), getSectionArrayAll()));
	}

	/**
	 * 予定簿情報のセット
	 * @param kcode 社員コード
	 * @param scode 所属コード
	 * @param Hizuke 日付
	 * @param workTypeCode 勤務形態コード
	 * @return dto 対象DTO
	 * @throws Exception
	 */
	protected MScheduleDto setScheduleInfo(
			String kcode, 
			String scode, 
			String[] arySchedule
	) throws Exception {
		MScheduleDto dto = new MScheduleDto();
		dto.setKCode(kcode);
		dto.setHizuke(arySchedule[0]);
		dto.setNen(MospUtility.getYear(util.convStringDateToDate(dto.getHizuke())));
		dto.setTuki(MospUtility.getMonth(util.convStringDateToDate(dto.getHizuke())));
		dto.setHi(MospUtility.getDay(util.convStringDateToDate(dto.getHizuke())));
		dto.setSyozoku(scode);
		if (isWeekHoliday(arySchedule[1])) {
			// 週休の場合
			dto.setKinmu(CommonConst.ATTENDANCE_TYPE_WEEK_HOLIDAY);
			dto.setSyJikoku("");
			dto.setTaJikoku("");
			dto.setSnRiyuu(CommonConst.NUM_ATTENDANCE_REQUEST);
			dto.setUpdtTimes(util.getDateTime(new Date()));
		} else {
			MWorkTypeDto workTypeDto = workTypeMap.get(arySchedule[1]);
			dto.setKinmu(workTypeDto.getShiftCode());
			dto.setSyJikoku(util.convIntegerTimeToStringTime(workTypeDto.getStartTime()));
			dto.setSyTimes(util.getDateTime(new Date()));
			dto.setTaJikoku(util.convIntegerTimeToStringTime(workTypeDto.getQuitTime()));
			dto.setKinmuJi(workTypeDto.getWorkTime());
			dto.setKyukeiJi(workTypeDto.getBreakTime());
			dto.setTaTimes(util.getDateTime(new Date()));
			dto.setSnRiyuu(CommonConst.NUM_ATTENDANCE_REQUEST);
			dto.setUpdtTimes(util.getDateTime(new Date()));
		}
		return dto;
	}

	/**
	 * 出勤簿の登録
	 * @param dto
	 * @throws Exception
	 */
	protected void insert(MSyukkinboDto dto, VoInterface vo) throws Exception {
		// 出勤簿用DAO準備 
		prepareMSyukkinboDao();
		// 存在チェック
		chkDuplicate(getSyukkinboInfo(dto.getKCode(), dto.getHizuke()), vo);
		// データの挿入
		syukkinboDao.insert(dto);
		// DTOの再取得
		chkInsert(getSyukkinboInfo(dto.getKCode(), dto.getHizuke()));
	}

	/**
	 * 予定簿の登録
	 * @param dto
	 * @throws Exception
	 */
	protected void registSchedule(MScheduleDto dto, VoInterface vo) throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		prepareMScheduleDao();
		MScheduleDto currentDto = getScheduleInfo(dto.getKCode(), dto.getHizuke());
		if (chkExistDto(currentDto)) {
			// 排他確認
			chkExclusive(currentDto, scheduleDao.findForUpdate(dto.getKCode(), dto.getHizuke()), vo);
			// 更新
			scheduleDao.update(dto);
		} else {
			// 存在チェック
			chkDuplicate(scheduleDao.findForKey(dto.getKCode(), dto.getHizuke()), vo);
			// 登録
			scheduleDao.insert(dto);
		}
		// DTOの再取得
		currentDto = scheduleDao.findForKey(dto.getKCode(), dto.getHizuke());		
		chkUpdate(currentDto);
	}

	/**
	 * 出勤簿用情報設定
	 * @param dto MScheduleDto
	 * @return mSyukkinboDto MSyukkinboDto
	 * @throws Exception
	 */
	protected MSyukkinboDto copyScheduleInfo(MScheduleDto dto) throws Exception {
		MSyukkinboDto mSyukkinboDto = new MSyukkinboDto();
		mSyukkinboDto.setKCode		(dto.getKCode()		);
		mSyukkinboDto.setHizuke		(dto.getHizuke()	);
		mSyukkinboDto.setNen		(dto.getNen()		);
		mSyukkinboDto.setTuki		(dto.getTuki()		);
		mSyukkinboDto.setHi			(dto.getHi()		);
		mSyukkinboDto.setSyozoku	(dto.getSyozoku()	);
		mSyukkinboDto.setNinsyo		(dto.getNinsyo()	);
		mSyukkinboDto.setSyJikoku	(dto.getSyJikoku()	);
		mSyukkinboDto.setKinmu		(dto.getKinmu()		);
		mSyukkinboDto.setSHankyuKb	(dto.getSHankyuKb()	);
		mSyukkinboDto.setKyusyuKb	(dto.getKyusyuKb()	);
		mSyukkinboDto.setTiRiyuu	(dto.getTiRiyuu()	);
		mSyukkinboDto.setTiComent	(dto.getTiComent()	);
		mSyukkinboDto.setTiSyoumei	(dto.getTiSyoumei()	);
		mSyukkinboDto.setTiJikan	(dto.getTiJikan()	);
		mSyukkinboDto.setSyTimes	(dto.getSyTimes()	);
		mSyukkinboDto.setTaJikoku	(dto.getTaJikoku()	);
		mSyukkinboDto.setKinmuJi	(dto.getKinmuJi()	);
		mSyukkinboDto.setKyukeiJi	(dto.getKyukeiJi()	);
		mSyukkinboDto.setTHankyuKb	(dto.getTHankyuKb()	);
		mSyukkinboDto.setSoRiyuu	(dto.getSoRiyuu()	);
		mSyukkinboDto.setSoComent	(dto.getSoComent()	);
		mSyukkinboDto.setSoSyoumei	(dto.getSoSyoumei()	);
		mSyukkinboDto.setSoJikan	(dto.getSoJikan()	);
		mSyukkinboDto.setZaJikan	(dto.getZaJikan()	);
		mSyukkinboDto.setKsJikan	(dto.getKsJikan()	);
		mSyukkinboDto.setSnJikan	(dto.getSnJikan()	);
		mSyukkinboDto.setSyokuji	(dto.getSyokuji()	);
		mSyukkinboDto.setCyoku1		(dto.getCyoku1()	);
		mSyukkinboDto.setCyoku2		(dto.getCyoku2()	);
		mSyukkinboDto.setCyoku3		(dto.getCyoku3()	);
		mSyukkinboDto.setHoka1		(dto.getHoka1()		);
		mSyukkinboDto.setHoka2		(dto.getHoka2()		);
		mSyukkinboDto.setHoka3		(dto.getHoka3()		);
		mSyukkinboDto.setHoka4		(dto.getHoka4()		);
		mSyukkinboDto.setHoka5		(dto.getHoka5()		);
		mSyukkinboDto.setTaTimes	(dto.getTaTimes()	);
		mSyukkinboDto.setKKRiyuu	(dto.getKKRiyuu()	);
		mSyukkinboDto.setDaiKyuJyu	(dto.getDaiKyuJyu()	);
		mSyukkinboDto.setKKComent	(dto.getKKComent()	);
		mSyukkinboDto.setKKSyoumei	(dto.getKKSyoumei()	);
		mSyukkinboDto.setKKJikan	(dto.getKKJikan()	);
		mSyukkinboDto.setKKTimes	(dto.getKKTimes()	);
		mSyukkinboDto.setSnRiyuu	(dto.getSnRiyuu()	);
		mSyukkinboDto.setSnComent	(dto.getSnComent()	);
		mSyukkinboDto.setSnTimes	(dto.getSnTimes()	);
		mSyukkinboDto.setUpdtTimes	(dto.getUpdtTimes()	);
		return mSyukkinboDto;
	}

	/*勤怠集計関連*/

	/**
	 * 未承認有無検索
	 * @param dto 対象DTO
	 * @param targetMonth 選択年月
	 * @return true…未承認無し、false…未承認有り
	 * @throws Exception
	 */
	protected boolean checkApproval(CompileAmendmentDto dto, Date targetMonth) throws Exception {
		// DBコネクションの取得
		if (conn == null) {
			getConnection();
		}
		boolean isAllApproved = false;
		// 出勤簿の取得と準備
		getAttendanceList(dto.getKCode(), targetMonth);
		// 出勤簿日集計データ取得
		//getAttendanceDaily();
		// 承認・未承認件数作成
		int[] number = makeApprovalNumber();
		// 未承認件数
		if (number[1] == 0 && number[2] > 0) {
			isAllApproved = true;
		}
		return isAllApproved;
	}

	/**
	 * 勤怠月集計
	 * @param kCode			対象社員コード
	 * @param targetMonth	対象年月
	 * @return	mKintaiDto	集計済みDTO
	 * @throws Exception
	 */
	protected MKintaiDto setCompileMonth(String kCode, Date targetMonth) throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// DTOの初期化
		MKintaiDto mKintaiDto = new MKintaiDto();
		// 変数宣言、変数の初期化
		// 勤務時間計
		int totalWork = 0;
		// 休憩時間計
		int totalInterbal = 0;
		// 遅刻時間計
		int totalLate = 0;
		// 早退時間計
		int totalLeave = 0;
		// 残業時間計
		int totalOver = 0;
		// 休出時間計
		int totalHolidayWork = 0;
		// 深夜時間計
		int totalLateNight = 0;
		// 出勤日数計
		double totalWorkDays = 0;
		// 出勤回数計
		int totalWorkNumber = 0;
		// 有休日数計
		double totalPaidHoliday = 0;
		// 特別休暇計
		int totalParticularHoliday = 0;
		// 欠勤日数計
		int totalAbsence = 0;
		// 傷病休暇計
		int totalMedicalLeave = 0;
		// 代休日数計
		int totalCompensationDay =0;
		// 振替休暇計
		int totalTransfer = 0;
		// 其他休暇計
		int totalOther = 0;
		// 遅刻早退数
		int leaveAndLate = 0;
		// 手当
		int syokuji = 0;
		int cyoku1 = 0;
		int cyoku2 = 0;
		int cyoku3 = 0;
		int hoka1 = 0;
		int hoka2 = 0;
		int hoka3 = 0;
		int hoka4 = 0;
		int hoka5 = 0;
		// 二時間年休数
		int nijikyu = 0;
		// 日集計データ取得
		Iterator<MSyukkinboDto> it = attendanceList.iterator();
		// 集計開始
		while (it.hasNext()) {
			MSyukkinboDto dto = it.next();
			// 勤怠項目
			if (isAvailableWorkType(dto)) {
				// 勤務時間
				totalWork += dto.getKinmuJi();
				// 休憩時間
				totalInterbal += dto.getKyukeiJi();
				// 遅刻時間
				totalLate += dto.getTiJikan();
				// 早退時間
				totalLeave += dto.getSoJikan();
				// 残業時間
				totalOver += dto.getZaJikan();
				// 休出時間
				totalHolidayWork += dto.getKsJikan();
				// 深夜時間
				totalLateNight += dto.getSnJikan();
				// 出勤日数
				if (dto.getKinmuJi() > 0) {
					totalWorkDays++;
					totalWorkNumber++;
				}
				// 遅刻早退数
				if (dto.getTiJikan() > 0 || dto.getSoJikan() > 0) {
					leaveAndLate++;
				}
				// 手当
				syokuji += dto.getSyokuji();
				cyoku1 += dto.getCyoku1();
				cyoku2 += dto.getCyoku2();
				cyoku3 += dto.getCyoku3();
				hoka1 += dto.getHoka1();
				hoka2 += dto.getHoka2();
				hoka3 += dto.getHoka3();
				hoka4 += dto.getHoka4();
				hoka5 += dto.getHoka5();
				// 半休
				if (isStartHalfHoliday(dto) || isQuitHalfHoliday(dto)) {
					totalPaidHoliday += 0.5;
					totalWorkDays -= 0.5;
				}
				// 二時間年休数
				nijikyu += dto.getNijiKyu();
			} else {
				// 休暇項目
				if (!dto.getKKRiyuu().equals("")) {
					if (dto.getKKRiyuu().equals(aryHolidayReason[0][0])) {
						// 有給休暇（m_code, 休暇理由, tcode="0"）
						totalPaidHoliday++;
					} else if (dto.getKKRiyuu().equals(aryHolidayReason[1][0])) {
						// 特別休暇（m_code, 休暇理由, tcode="1"）
						totalParticularHoliday++;
					} else if (dto.getKKRiyuu().equals(aryHolidayReason[2][0])) {
						// 欠勤日数（m_code, 休暇理由, tcode="2"）
						totalAbsence++;
					} else if (dto.getKKRiyuu().equals(aryHolidayReason[3][0])) {
						// 傷病休暇（m_code, 休暇理由, tcode="3"）
						totalMedicalLeave++;
					} else if (dto.getKKRiyuu().equals(aryHolidayReason[4][0])) {
						// 代休日数（m_code, 休暇理由, tcode="4"）
						totalCompensationDay++;
					} else if (dto.getKKRiyuu().equals(aryHolidayReason[5][0])) {
						// 振替休暇（m_code, 休暇理由, tcode="5"）
						totalTransfer++;
					} else {
						// 其他休暇（m_code, 休暇理由, tcode="6"より上）
						totalOther++;
					}
				}
			}
		}
		// DTOに値をセット
		mKintaiDto.setKCode(kCode);
		// 支給年月
		mKintaiDto.setSikyuYM(util.convDateToStringYearMonthShort(targetMonth));
		// 支給年
		mKintaiDto.setSNen(MospUtility.getYear(getCalcPayment()));
		// 支給月
		mKintaiDto.setSTuki(MospUtility.getMonth(getCalcPayment()));
		// 支給日
		mKintaiDto.setSHi(MospUtility.getDay(getCalcPayment()));
		// 出勤日数
		mKintaiDto.setSNissu(totalWorkDays);
		// 出勤回数
		mKintaiDto.setSKaisu(totalWorkNumber);
		// 勤務時間合計
		mKintaiDto.setKinmuJi(totalWork);
		// 休憩時間合計
		mKintaiDto.setKyukeiJi(totalInterbal);
		// 有給休暇日数
		mKintaiDto.setYukyu(totalPaidHoliday);
		// 特別休暇日数
		mKintaiDto.setTokuKyu(totalParticularHoliday);
		// 欠勤休暇日数
		mKintaiDto.setKekkin(totalAbsence);
		// 傷病休暇日数
		mKintaiDto.setSKekkin(totalMedicalLeave);
		// 代休日数
		mKintaiDto.setDaiKyu(totalCompensationDay);
		// 振替休暇日数
		mKintaiDto.setFurikae(totalTransfer);
		// 其他休暇日数
		mKintaiDto.setSonota(totalOther);
		// 遅刻早退数
		mKintaiDto.setTiSoKai(leaveAndLate);
		// 遅刻早退時間合計
		mKintaiDto.setTiJikan(totalLate + totalLeave);
		// 残業時間合計
		mKintaiDto.setZaJikan(totalOver);
		// 休出時間合計
		mKintaiDto.setKsJikan(totalHolidayWork);
		// 深夜時間合計
		mKintaiDto.setSnJikan(totalLateNight);
		// 皆勤（欠勤、特別休暇、傷病、遅刻早退数の合計）
		if ((totalAbsence + totalParticularHoliday + totalMedicalLeave + leaveAndLate) == 0
				&& totalWorkDays != 0) {
			mKintaiDto.setKaikin(1);
		}
		// 役職による手当支給設定
		MYakusyokuDto positionDto = getHoldingPositionInfo(kCode);
		if (chkExistDto(positionDto)) {
			if (positionDto.getKaikin().equals(CommonConst.NAM_COMMON_FLAG_OFF)) {
				mKintaiDto.setKaikin(0);
			}
		}
		// 手当
		// 食事手当合計
		mKintaiDto.setSyokujiKaisu(syokuji);
		// １直手当合計
		mKintaiDto.setCyokuKaisu1(cyoku1);
		// ２直手当合計
		mKintaiDto.setCyokuKaisu2(cyoku2);
		// ３直手当合計
		mKintaiDto.setCyokuKaisu3(cyoku3);
		// その他手当１合計
		mKintaiDto.setHokaKaisu1(hoka1);
		// その他手当２合計
		mKintaiDto.setHokaKaisu2(hoka2);
		// その他手当３合計
		mKintaiDto.setHokaKaisu3(hoka3);
		// その他手当４合計
		mKintaiDto.setHokaKaisu4(hoka4);
		// その他手当５合計
		mKintaiDto.setHokaKaisu5(hoka5);
		// 二時間年休合計
		mKintaiDto.setNijiKyu(nijikyu);
		return mKintaiDto;
	}

	/**
	 * 勤務パターン配列取得
	 * @param rotationCode
	 * @return	aryRotaiton	勤務パターン配列
	 * @throws Exception
	 */
	protected String[] getRotationArray(String rotationCode) throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		CmRotationDao cmRotationDao = new CmRotationDao();
		cmRotationDao.initDao(cfg, cmd, aspUser, user, conn);
		CmRotationDto dto = cmRotationDao.findForKey(mKihon.getKCode(), rotationCode);
		String[] aryRotaiton = new String[10];
		if (chkExistDto(dto)) {
			aryRotaiton[0] = dto.getDay1();
			aryRotaiton[1] = dto.getDay2();
			aryRotaiton[2] = dto.getDay3();
			aryRotaiton[3] = dto.getDay4();
			aryRotaiton[4] = dto.getDay5();
			aryRotaiton[5] = dto.getDay6();
			aryRotaiton[6] = dto.getDay7();
			aryRotaiton[7] = dto.getDay8();
			aryRotaiton[8] = dto.getDay9();
			aryRotaiton[9] = dto.getDay10();
		} else {
			aryRotaiton = new String[0];
		}
		return aryRotaiton;
	}

	/**
	 * 祝祭日フラグ取得
	 * @param rotationCode
	 * @return 0…false、1…true
	 * @throws Exception
	 */
	protected boolean getPublicHolidayFlag(String rotationCode) throws Exception {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		CmRotationDao cmRotationDao = new CmRotationDao();
		cmRotationDao.initDao(cfg, cmd, aspUser, user, conn);
		CmRotationDto dto = cmRotationDao.findForKey(mKihon.getKCode(), rotationCode);
		if (chkExistDto(dto) && dto.getHolidayFlag() != 0) {
			return true;
		}
		return false;
	}

	/*勤怠承認関連*/

	/**
	 * 勤怠承認処理
	 * @param kcode			対象者
	 * @param targetDate	対象年月日
	 * @param reason		承認理由
	 * @param comment		承認コメント
	 * @param approver		承認者
	 * @throws Exception
	 */
	protected void runApprovalProcess(
			String kcode,
			String targetDate,
			String reason,
			String comment,
			String approver
	) throws Exception {
		// 情報の取得
		MSyukkinboDto dto = getSyukkinboInfo(kcode, targetDate, true);
		// 排他確認
		chkExist(dto);
		// 承認情報設定
		dto.setNinsyo(approver);
		dto.setSnRiyuu(reason);
		dto.setSnComent(comment);
		dto.setSnTimes(util.getDateTime(util.getNowDate()));
		dto.setUpdtTimes(util.getDateTime(util.getNowDate()));
		// 承認処理
		syukkinboDao.update(dto);
		// DTOの再取得
		chkUpdate(getSyukkinboInfo(dto.getKCode(), dto.getHizuke()));
	}

	/**
	 * 出勤簿申請中フラグ取得
	 * @param dto		対象出勤簿DTO
	 * @return
	 * <p>
	 * 申請中ならtrue、そうでない場合false
	 * </p>
	 */
	protected boolean isRequest(String snriyuu) {
		return snriyuu.equals(getApprovalStatusCodeArray()[0]) ? true : false;
	}

	/**
	 * 出勤簿申請中フラグ取得
	 * @param dto		対象出勤簿DTO
	 * @return
	 * <p>
	 * 申請中ならtrue、そうでない場合false
	 * </p>
	 */
	protected boolean isRequest(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isRequest(dto.getSnRiyuu());
		}
		return false;
	}

	/**
	 * 出勤簿一次承認済フラグ取得
	 * @param dto		対象出勤簿DTO
	 * @return
	 * <p>
	 * 承認済ならtrue、そうでない場合false
	 * </p>
	 */
	protected boolean is1stApproved(String snriyuu) {
		return snriyuu.equals(getApprovalStatusCodeArray()[1]) ? true : false;
	}

	/**
	 * 出勤簿一次承認済フラグ取得
	 * @param dto		対象出勤簿DTO
	 * @return
	 * <p>
	 * 承認済ならtrue、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean is1stApproved(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return is1stApproved(dto.getSnRiyuu());
		}
		return false;
	}

	/**
	 * 出勤簿二次承認済フラグ取得
	 * @param dto		対象出勤簿DTO
	 * @return
	 * <p>
	 * 承認済ならtrue、そうでない場合false
	 * </p>
	 */
	protected boolean is2ndApproved(String snriyuu) {
		return snriyuu.equals(getApprovalStatusCodeArray()[3])? true: false;
	}

	/**
	 * 出勤簿二次承認済フラグ取得
	 * @param dto		対象出勤簿DTO
	 * @return
	 * <p>
	 * 承認済ならtrue、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean is2ndApproved(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return is2ndApproved(dto.getSnRiyuu());
		}
		return false;
	}

	/**
	 * 出勤簿承認済フラグ取得
	 * @param dto		対象出勤簿DTO
	 * @return
	 * <p>
	 * 承認済ならtrue、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean isApproved(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			if (is1stApproved(dto) || is2ndApproved(dto)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 休出判断
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param code		対象申請種類
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 */
	protected boolean isWorkOnHoliday(String code) {
		return code.equals(CommonConst.NUM_WORK_ON_HOLIDAY_FLAG_ON) ? true : false;
	}

	/**
	 * 休出判断
	 * <p>	2009/04/21	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean isWorkOnHoliday(MScheduleDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isWorkOnHoliday(dto.getKyusyuKb());
		}
		return false;
	}

	/**
	 * 休出判断
	 * <p>	2009/04/21	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean isWorkOnHoliday(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isWorkOnHoliday(dto.getKyusyuKb());
		}
		return false;
	}

	/**
	 * 前半休判断
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param code		対象申請種類
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 */
	protected boolean isStartHalfHoliday(String code) {
		return code.equals(CommonConst.NUM_START_HALF_HOLIDAY_FLAG_ON) ? true : false;
	}

	/**
	 * 前半休判断
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean isStartHalfHoliday(MScheduleDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isStartHalfHoliday(dto.getSHankyuKb());
		}
		return false;
	}

	/**
	 * 前半休判断
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean isStartHalfHoliday(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isStartHalfHoliday(dto.getSHankyuKb());
		}
		return false;
	}

	/**
	 * 後半休判断
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param code		対象申請種類
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 */
	protected boolean isQuitHalfHoliday(String code) {
		return code.equals(CommonConst.NUM_QUIT_HALF_HOLIDAY_FLAG_ON) ? true : false;
	}

	/**
	 * 後半休判断
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean isQuitHalfHoliday(MScheduleDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isQuitHalfHoliday(dto.getTHankyuKb());
		}
		return false;
	}

	/**
	 * 後半休判断
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean isQuitHalfHoliday(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isQuitHalfHoliday(dto.getTHankyuKb());
		}
		return false;
	}

	/**
	 * 休暇、年休判断フラグ
	 * <p>	2009/04/21	m.yoshida	追加		</p>
	 * @param kinmu			対象勤務形態コード
	 * @return
	 * <p>
	 * 休暇、年休だった場合true、そうでない場合false
	 * </p>
	 */
	protected boolean isHoliday(String kinmu) {
		return kinmu.equals(CommonConst.ATTENDANCE_TYPE_HOLIDAY);
	}

	/**
	 * 休暇、年休判断フラグ
	 * <p>	2009/04/21	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 予定簿が休暇、年休だった場合true、そうでない場合false
	 * </p>
	 */
	protected boolean isHoliday(MScheduleDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isHoliday(dto.getKinmu());
		}
		return false;
	}

	/**
	 * 休暇、年休判断フラグ
	 * <p>	2009/04/21	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 出勤簿が休暇、年休だった場合true、そうでない場合false
	 * </p>
	 */
	protected boolean isHoliday(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isHoliday(dto.getKinmu());
		}
		return false;
	}

	/**
	 * 週休判断フラグ
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kinmu			対象勤務形態コード
	 * @return
	 * <p>
	 * 週休だった場合true、そうでない場合false
	 * </p>
	 */
	protected boolean isWeekHoliday(String kinmu) {
		return kinmu.equals(CommonConst.ATTENDANCE_TYPE_WEEK_HOLIDAY);
	}

	/**
	 * 週休判断フラグ
	 * <p>	2009/04/21	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 予定簿が週休だった場合true、そうでない場合false
	 * </p>
	 */
	protected boolean isWeekHoliday(MScheduleDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isWeekHoliday(dto.getKinmu());
		}
		return false;
	}

	/**
	 * 週休判断フラグ
	 * <p>	2009/04/21	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 予定簿が週休だった場合true、そうでない場合false
	 * </p>
	 */
	protected boolean isWeekHoliday(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return isWeekHoliday(dto.getKinmu());
		}
		return false;
	}

	/**
	 * 勤務可能判断フラグ
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param dto			対象DTO
	 * @return
	 * <p>
	 * 勤務可能な勤務形態の場合true、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean isAvailableWorkType(MScheduleDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return !isHoliday(dto) 	&& !isWeekHoliday(dto);
		}
		return false;
	}

	/**
	 * 勤務可能判断フラグ
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param dto			対象DTO
	 * @return
	 * <p>
	 * 勤務可能な勤務形態の場合true、そうでない場合false
	 * </p>
	 * @throws Exception
	 */
	protected boolean isAvailableWorkType(MSyukkinboDto dto) throws Exception {
		if (chkExistDto(dto)) {
			return !isHoliday(dto) && !isWeekHoliday(dto);
		}
		return false;
	}

	/**
	 * カンマ区切りの日付を取得
	 * @param year		
	 * @param month
	 * @param day
	 * @return
	 */
	protected String getMessageDate(String year, String month, String day) {
		return util.convStringDateFormatted(year, month, day);
	}

}
