/*
 * MosP - Mind Open Source Project    http://www.mosp.jp/
 * Copyright (C) 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.common.part;

import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import jp.mosp.common.CommonConst;
import jp.mosp.common.common.MospConst;
import jp.mosp.common.common.MospUtility;
import jp.mosp.common.dto.HumanBasisDtoInterface;
import jp.mosp.common.dto.KintaiCommonDtoInterface;
import jp.mosp.common.part.PartInfo;
import jp.mosp.common.utils.DateUtil;
import jp.mosp.common.utils.NumberUtil;
import jp.mosp.common.utils.StringUtil;
import jp.mosp.common.utils.TimeUtil;
import jp.mosp.common.utils.VariousUtil;
import jp.mosp.kintai.common.dto.CmWorkTypeDto;
import jp.mosp.kintai.kintai.dao.MSyukkinboDao;
import jp.mosp.kintai.kintai.dto.MSyukkinboDto;
import jp.mosp.kintai.schedule.dao.MScheduleDao;
import jp.mosp.kintai.schedule.dto.MScheduleDto;
import jp.mosp.legal.LegalConst;
import jp.mosp.mospcommon.system.AgreementBaseInfo;

/**
 * 勤怠に関するPartクラス
 * @author yoshida
 * 	@version	0.0.17
 */
public class KintaiCommonPart extends KintaiBasePart {
	
	/**
	 * M_SYUKKINBO
	 */
	public static final String	SYUKKINBO_TABLE	= MSyukkinboDao.TABLE;
	

	/**
	 * コンストラクタ
	 */
	public KintaiCommonPart() {
		super();
	}
	
	/**
	 * コンストラクタ
	 * @param partInfo Partを利用する際に必要な情報
	 */
	public KintaiCommonPart(PartInfo partInfo) {
		super(partInfo);
	}
	

	/**
	 * MScheduleDaoインスタンス
	 */
	private MScheduleDao	scheduleDao;
	

	/**
	 * 初期化済み予定簿用DAO取得
	 * @return	初期化済みMScheduleDaoインスタンス
	 * @throws Exception	例外処理が発生した場合
	 */
	public MScheduleDao getMScheduleDao() throws Exception {
		if (VariousUtil.isNull(scheduleDao)) {
			scheduleDao = (MScheduleDao)getPreparedDao(MScheduleDao.class.getCanonicalName());
		}
		return scheduleDao;
	}
	

	/**
	 * MSyukkinboDaoインスタンス
	 */
	private MSyukkinboDao	syukkinboDao;
	

	/**
	 * 初期化済み出勤簿用DAO取得
	 * @return	初期化済みMSyukkinboDaoインスタンス
	 * @throws Exception	例外処理が発生した場合
	 */
	public MSyukkinboDao getMSyukkinboDao() throws Exception {
		if (VariousUtil.isNull(syukkinboDao)) {
			syukkinboDao = (MSyukkinboDao)getPreparedDao(MSyukkinboDao.class.getCanonicalName());
		}
		return syukkinboDao;
	}
	
	/**
	 * 休出判断
	 * <p>	2009/06/24	m.yoshida	追加		</p>
	 * @param code		対象申請種類
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 */
	public static boolean isWorkOnHoliday(String code) {
		return CommonConst.NUM_WORK_ON_HOLIDAY_FLAG_ON.equals(code);
	}
	
	/**
	 * 前半休判断
	 * <p>	2009/06/24	m.yoshida	追加		</p>
	 * @param code		対象申請種類
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 */
	public static boolean isStartHalfHoliday(String code) {
		return CommonConst.NUM_START_HALF_HOLIDAY_FLAG_ON.equals(code);
	}
	
	/**
	 * 後半休判断
	 * <p>	2009/06/24	m.yoshida	追加		</p>
	 * @param code		対象申請種類
	 * @return
	 * <p>
	 * 休日勤務ならtrue、そうでない場合false
	 * </p>
	 */
	public static boolean isQuitHalfHoliday(String code) {
		return CommonConst.NUM_QUIT_HALF_HOLIDAY_FLAG_ON.equals(code);
	}
	
	/**
	 * 休暇、有休判断フラグ
	 * <p>	2009/06/24	m.yoshida	追加		</p>
	 * @param kinmu			対象勤務形態コード
	 * @return
	 * <p>
	 * 休暇、有休だった場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isHoliday(String kinmu) {
		return CommonConst.ATTENDANCE_TYPE_HOLIDAY.equals(kinmu);
	}
	
	/**
	 * 週休判断フラグ
	 * <p>	2009/06/24	m.yoshida	追加	</p>
	 * @param kinmu			対象勤務形態コード
	 * @return
	 * <p>
	 * 週休だった場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isWeekHoliday(String kinmu) {
		return CommonConst.ATTENDANCE_TYPE_WEEK_HOLIDAY.equals(kinmu);
	}
	
	/**
	 * 休出判断
	 * <p>	2009/06/24	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 休日出勤ならtrue、そうでない場合false
	 * </p>
	 */
	public static boolean isWorkOnHoliday(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return isWorkOnHoliday(dto.getKyusyuKb());
		}
		return false;
	}
	
	/**
	 * 前半休判断
	 * <p>	2009/06/24	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 前半休ならtrue、そうでない場合false
	 * </p>
	 */
	public static boolean isStartHalfHoliday(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return isStartHalfHoliday(dto.getSHankyuKb());
		}
		return false;
	}
	
	/**
	 * 後半休判断
	 * <p>	2009/06/24	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 後半休ならtrue、そうでない場合false
	 * </p>
	 */
	public static boolean isQuitHalfHoliday(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return isQuitHalfHoliday(dto.getTHankyuKb());
		}
		return false;
	}
	
	/**
	 * 休暇、有休判断フラグ
	 * <p>	2009/06/24	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 出勤・予定簿が休暇、有休だった場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isHoliday(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return isHoliday(dto.getKinmu());
		}
		return false;
	}
	
	/**
	 * 週休判断フラグ
	 * <p>	2009/06/24	m.yoshida	追加		</p>
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 出勤・予定簿が週休だった場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isWeekHoliday(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return isWeekHoliday(dto.getKinmu());
		}
		return false;
	}
	
	/**
	 * 勤務可能判断フラグ
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param dto			対象DTO
	 * @return
	 * <p>
	 * 勤務可能な勤務形態の場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isAvailableWorkType(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return !isHoliday(dto) && !isWeekHoliday(dto) && !isOfficialHoliday(dto);
		}
		return false;
	}
	
	/**
	 * 深夜時間開始時刻
	 * @return	深夜時間開始時刻（分）
	 * @throws Exception	例外処理が発生した場合
	 */
	public int getLateNightStart() throws Exception {
		// M_CODEから値を取得
		String conf = part().mospcode().findTchange(CommonConst.TID_WORK_SYSTEM, CommonConst.TCD_LATE_NIGHT);
		return TimeUtil.convStringTimeToIntegerTime(conf.split(CommonConst.STR_SLASH_SEPARATOR)[0]);
	}
	
	/**
	 * 深夜時間終了時刻
	 * @return	深夜時間終了時刻（分）
	 * @throws Exception	例外処理が発生した場合
	 */
	public int getLateNightEnd() throws Exception {
		// M_CODEから値を取得
		String conf = part().mospcode().findTchange(CommonConst.TID_WORK_SYSTEM, CommonConst.TCD_LATE_NIGHT);
		return TimeUtil.convStringTimeToIntegerTime(conf.split(CommonConst.STR_SLASH_SEPARATOR)[1]);
	}
	
	/**
	 * 一日休暇時間取得
	 * @return	一日休暇時間（分）
	 * @throws Exception	例外処理が発生した場合
	 */
	public int getAllHolidayTimes() throws Exception {
		String conf = part().mospcode().findTchange(CommonConst.TID_WORK_SYSTEM, CommonConst.TCD_HOLIDAY_HOURS);
		return TimeUtil.convStringTimeToIntegerTime(conf.split(CommonConst.STR_SLASH_SEPARATOR)[0]);
	}
	
	/**
	 * 半日休暇時間取得
	 * @return	半日休暇時間（分）
	 * @throws Exception	例外処理が発生した場合
	 */
	public int getHalfHolidayTimes() throws Exception {
		String conf = part().mospcode().findTchange(CommonConst.TID_WORK_SYSTEM, CommonConst.TCD_HOLIDAY_HOURS);
		return TimeUtil.convStringTimeToIntegerTime(conf.split(CommonConst.STR_SLASH_SEPARATOR)[1]);
	}
	
	/**
	 * 登録単位時間取得
	 * @return	登録単位時間（分）
	 * @throws Exception	例外処理が発生した場合
	 */
	public int getInputUnitTimes() throws Exception {
		return NumberUtil.getIntParam(part().mospcode().findTchange(CommonConst.TID_INPUT_UNIT_TIMES,
				CommonConst.TCD_MINUTES));
	}
	
	/**
	 * 自動計算フラグ取得
	 * @return	自動計算フラグ
	 * @throws Exception	例外処理が発生した場合
	 */
	public boolean isAutoCalc() throws Exception {
		String autoCalc = part().mospcode().findTchange(CommonConst.TID_WORK_SYSTEM,
				CommonConst.TCD_AUTOMATIC_CALCULATION);
		if (String.valueOf(MospConst.DELETE_FLAG_OFF).equals(autoCalc)) {
			return true;
		}
		return false;
	}
	
	/**
	 * 勤怠入力自動計算フラグ取得。
	 * @since 0.0.16
	 * @return 勤怠入力自動計算フラグ
	 * @throws Exception	例外処理が発生した場合
	 */
	public boolean isDailyAutoCalc() throws Exception {
		return isAutoCalc()
				&& StringUtil.isFlagOff(part().mospcode().findTchange(CommonConst.TID_WORK_SYSTEM,
						CommonConst.TCD_CALCULATION_PROCESS));
	}
	
	/**
	 * 勤怠集計自動計算フラグ取得。
	 * @return 勤怠集計自動計算フラグ
	 * @throws Exception 	例外処理が発生した場合
	 */
	public boolean isMonthlyAutoCalc() throws Exception {
		return isAutoCalc()
				&& StringUtil.isFlagOn(part().mospcode().findTchange(CommonConst.TID_WORK_SYSTEM,
						CommonConst.TCD_CALCULATION_PROCESS));
	}
	
	/**
	 * 代替休日判断フラグ
	 * @since	0.0.2
	 * @param kinmu				対象勤務形態コード
	 * @param kkRiyuu			対象休暇理由コード
	 * @return
	 * <p>
	 * 勤務形態コードと休暇理由コードが代替休日だった場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isCompensationHoliday(String kinmu, String kkRiyuu) {
		if (isHoliday(kinmu) && CommonConst.CODE_HOLIDAY_REASON_COMPENSATION.equals(kkRiyuu)) {
			return true;
		}
		return false;
	}
	
	/**
	 * 代替休日判断フラグ
	 * @since	0.0.2
	 * @param dto				対象DTO
	 * @return
	 * <p>
	 * 勤務形態コードと休暇理由コードが代替休日だった場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isCompensationHoliday(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return isCompensationHoliday(dto.getKinmu(), dto.getKKRiyuu());
		}
		return false;
	}
	
	/**
	 * 時間外代休(全日)判断
	 * @param dto	対象DTO
	 * @return
	 * <p>
	 * 勤務形態コードと休暇理由コードが時間外代休(全日)だった場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isSubstituteAll(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto) && isHoliday(dto)) {
			return CommonConst.CODE_SUB_HOLIDAY_REQUEST.equals(dto.getKKRiyuu());
		}
		return false;
	}
	
	/**
	 * 有休判断フラグ
	 * @since	0.0.2
	 * @param kinmu					対象勤務形態コード
	 * @param kkRiyuu				対象休暇理由コード
	 * @return
	 * <p>
	 * 勤務形態コードと休暇理由コードが有休休暇だった場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isAllHoliday(String kinmu, String kkRiyuu) {
		if (isHoliday(kinmu) && PaidHolidayPart.isPaidHoliday(kkRiyuu)) {
			return true;
		}
		return false;
	}
	
	/**
	 * 有休判断フラグ
	 * @since	0.0.2
	 * @param dto				対象DTO
	 * @return
	 * <p>
	 * 勤務形態コードと休暇理由コードが有休休暇だった場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isAllHoliday(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return isAllHoliday(dto.getKinmu(), dto.getKKRiyuu());
		}
		return false;
	}
	
	/**
	 * 出勤簿用情報のコピー設定
	 * <p>	2009/07/01	m.yoshida	追加	</p>
	 * @since	0.0.2
	 * @param dto 対象予定簿、出勤簿DTO
	 * @return mSyukkinboDto MSyukkinboDto
	 */
	public static MSyukkinboDto copyToSyukkinbo(KintaiCommonDtoInterface dto) {
		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());
		mSyukkinboDto.setNijiKyu(dto.getNijiKyu());
		mSyukkinboDto.setWarimasi1(dto.getWarimasi1());
		mSyukkinboDto.setZKinmu(dto.getZKinmu());
		return mSyukkinboDto;
	}
	
	/**
	 * 内容の初期化
	 * @since	0.0.15
	 * @param dto	対象DTO
	 */
	public static void initKintaiInfo(KintaiCommonDtoInterface dto) {
		dto.setNinsyo("");
		dto.setSyJikoku("");
		dto.setKinmu("");
		dto.setSHankyuKb("");
		dto.setKyusyuKb("");
		dto.setTiRiyuu("");
		dto.setTiComent("");
		dto.setTiSyoumei("");
		dto.setTiJikan(0);
		dto.setSyTimes(DateUtil.getDateTime(DateUtil.getNowDate()));
		dto.setTaJikoku("");
		dto.setKinmuJi(0);
		dto.setKyukeiJi(0);
		dto.setTHankyuKb("");
		dto.setSoRiyuu("");
		dto.setSoComent("");
		dto.setSoSyoumei("");
		dto.setSoJikan(0);
		dto.setZaJikan(0);
		dto.setKsJikan(0);
		dto.setSnJikan(0);
		dto.setSyokuji(0);
		dto.setCyoku1(0);
		dto.setCyoku2(0);
		dto.setCyoku3(0);
		dto.setHoka1(0);
		dto.setHoka2(0);
		dto.setHoka3(0);
		dto.setHoka4(0);
		dto.setHoka5(0);
		dto.setTaTimes(DateUtil.getDateTime(DateUtil.getNowDate()));
		dto.setKKRiyuu("");
		dto.setDaiKyuJyu("");
		dto.setKKComent("");
		dto.setKKSyoumei("");
		dto.setKKJikan(0);
		dto.setKKTimes("");
		dto.setSnRiyuu("");
		dto.setSnComent("");
		dto.setSnTimes("");
		dto.setUpdtTimes(DateUtil.getDateTime(DateUtil.getNowDate()));
		dto.setNijiKyu(0);
		dto.setWarimasi1(0);
		dto.setZKinmu("");
	}
	
	/**
	 * 出勤簿情報一覧
	 * @since	0.0.3
	 * @param kCode			対象社員コード
	 * @param startDate		対象開始日(yyyy/MM/dd)
	 * @param endDate		対象終了日(yyyy/MM/dd)
	 * @return List 検索結果(DTOのList)
	 * @throws Exception	例外処理が発生した場合
	 */
	public List<MSyukkinboDto> getAttendanceList(String kCode, String startDate, String endDate) throws Exception {
		return getMSyukkinboDao().findForAttendanceList(kCode, startDate, endDate);
	}
	
	/**
	 * 出勤簿情報一覧
	 * @since	0.0.17
	 * @param kCode			対象社員コード
	 * @param startDate		対象開始日
	 * @param endDate		対象終了日
	 * @return List 検索結果(DTOのList)
	 * @throws Exception	例外処理が発生した場合
	 */
	public List<MSyukkinboDto> getAttendanceList(String kCode, Date startDate, Date endDate) throws Exception {
		return getAttendanceList(kCode, DateUtil.convDateFormatted(startDate), DateUtil.convDateFormatted(endDate));
	}
	
	/**
	 * 予定簿情報一覧
	 * @since	0.0.3
	 * @param kCode			対象社員コード
	 * @param startDate		対象開始日(yyyy/MM/dd)
	 * @param endDate		対象終了日(yyyy/MM/dd)
	 * @return List 検索結果(DTOのList)
	 * @throws Exception	例外処理が発生した場合
	 */
	public List<MScheduleDto> getScheduleList(String kCode, String startDate, String endDate) throws Exception {
		return getMScheduleDao().findForScheduleList(kCode, startDate, endDate);
	}
	
	/**
	 * 予定簿情報一覧
	 * @since	0.0.17
	 * @param kCode			対象社員コード
	 * @param startDate		対象開始日
	 * @param endDate		対象終了日
	 * @return List 検索結果(DTOのList)
	 * @throws Exception	例外処理が発生した場合
	 */
	public List<MScheduleDto> getScheduleList(String kCode, Date startDate, Date endDate) throws Exception {
		return getScheduleList(kCode, DateUtil.convDateFormatted(startDate), DateUtil.convDateFormatted(endDate));
	}
	
	/**
	 * 勤務開始時刻取得
	 * @since	0.0.4
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 勤務開始時刻（0時からの経過分数）。<br>
	 * もし入っていない場合は、0:00
	 * <p>
	 */
	public static int getWorkStartTime(KintaiCommonDtoInterface dto) {
		return TimeUtil.convStringTimeToIntegerTime(dto.getSyJikoku());
	}
	
	/**
	 * 勤務終了時刻取得
	 * @since	0.0.4
	 * @param dto		対象DTO
	 * @return
	 * <p>
	 * 勤務終了時刻（0時からの経過分数）。<br>
	 * もし入っていない場合は、0:00
	 * <p>
	 */
	public static int getWorkQuitTime(KintaiCommonDtoInterface dto) {
		return TimeUtil.convStringTimeToIntegerTime(dto.getTaJikoku());
	}
	
	/**
	 * 半休判断
	 * @since	0.0.5
	 * @param dto	対象DTO
	 * @return
	 * <p>
	 * 前半休または後半休ならtrue、そうでない場合false
	 * </p>
	 */
	public static boolean isHalfHoliday(KintaiCommonDtoInterface dto) {
		return isStartHalfHoliday(dto) || isQuitHalfHoliday(dto);
	}
	
	/**
	 * 勤怠計算機呼び出し
	 * @since	0.0.6
	 * @param shiftCode		対象勤務形態コード
	 * @return	勤怠計算機インスタンス
	 * @throws Exception 	例外処理
	 */
	public KintaiCalcPart getCalculator(String shiftCode) throws Exception {
		CmWorkTypeDto dto = part().worktype().getWorkTypeInfo(shiftCode);
		if (VariousUtil.isNull(dto)) {
			throw new NullPointerException();
		}
		// 勤怠計算
		KintaiCalcPart calc = new KintaiCalcPart();
		// 対象勤務形態情報設定
		calc.setWorkTypeInfo(dto.getStartTime(), dto.getQuitTime(), dto.getWorkTime(), dto.getBreakTime());
		// 深夜時間情報設定
		calc.setLateNightInfo(getLateNightStart(), getLateNightStart() + getLateNightEnd());
		// 半休時間
		calc.setHalfHoliday(getHalfHolidayTimes());
		// 法定労働時間（8時間）
		calc.setLegalHours(LegalConst.LEGAL_HOURS_PER_DAY * CommonConst.NUM_1HOUR_MIN);
		// 入力単位
		calc.setInputUnit(getInputUnitTimes());
		// 残業休憩情報設定
		calc.setOverTimeIntervalInfo(getBeforeOverTimeInterval(), getOverTimeUnitTime(), getOverTimeInterval());
		// 勤怠入力時丸め処理
		calc.setUseRoundNumber(isRoundNumberDaily());
		return calc;
	}
	
	/**
	 * 出勤項目計算
	 * @since	0.0.6
	 * @param dto			対象出勤簿DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public void runStartCalculate(KintaiCommonDtoInterface dto) throws Exception {
		// 勤怠計算機取得
		KintaiCalcPart calc = getCalculator(dto.getKinmu());
		// 出勤項目の計算
		calc.runCalcStartTime(getWorkStartTime(dto), isStartHalfHoliday(dto), isWorkOnHoliday(dto));
		// 遅刻時間セット
		dto.setTiJikan(calc.getLateTime());
	}
	
	/**
	 * 勤怠項目計算
	 * @since	0.0.6
	 * @param dto		対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public void runCalculatedInfo(KintaiCommonDtoInterface dto) throws Exception {
		// 勤怠計算機取得
		KintaiCalcPart calc = getCalculator(dto.getKinmu());
		Date targetDate = DateUtil.convStringDateToDate(dto.getHizuke());
		// 各項目の計算
		calc.runCalculate(
		// 出勤時刻算出
				getWorkStartTime(dto),
				// 退勤時刻算出
				getWorkQuitTime(dto),
				// 出勤半休
				isStartHalfHoliday(dto) || isOverTimeSubHolidayStart(dto),
				// 退勤半休
				isQuitHalfHoliday(dto) || isOverTimeSubHolidayQuit(dto),
				// 休出判断
				isWorkOnHoliday(dto));
		// 遅刻時間
		dto.setTiJikan(calc.getLateTime());
		// 勤務時間
		dto.setKinmuJi(calc.getWorkTime());
		// 早退時間
		dto.setSoJikan(calc.getLeaveTime());
		// 休憩時間
		dto.setKyukeiJi(calc.getIntervalTime());
		// 深夜時間
		dto.setSnJikan(calc.getLateNightTime());
		// 休出時間
		int workOnHolidayTime = 0;
		// 残業時間
		int overTime = calc.getOverTime();
		// 休日勤務の場合
		if (isWorkOnHoliday(dto)) {
			// 労使協定情報取得
			AgreementBaseInfo agreement = part().laborAgreement().getUserLaborAgreement(dto.getKCode(), targetDate);
			if (VariousUtil.isNotNull(agreement)) {
				// 所定休日の場合、すべて残業時間として扱う
				if (part().laborAgreement().isStandardHoliday(targetDate, agreement)) {
					overTime = calc.getHolidayWorkTime();
				}
				// 法定休日の場合、すべて休出時間として扱う
				if (LaborAgreementPart.isOfficialHoliday(targetDate, agreement)) {
					workOnHolidayTime = calc.getHolidayWorkTime();
				}
			} else {
				// 労使協定が無い場合、従来通り
				workOnHolidayTime = calc.getHolidayWorkTime();
			}
		}
		// 残業時間
		dto.setZaJikan(overTime);
		// 休出時間
		dto.setKsJikan(workOnHolidayTime);
	}
	
	/**
	 * 残業開始前休憩時間
	 * @since	0.0.7
	 * @return	残業開始前休憩時間（分）
	 * @throws Exception	例外処理が発生した場合
	 */
	public int getBeforeOverTimeInterval() throws Exception {
		return NumberUtil.getIntParam(part().mospcode().findTchange(CommonConst.TID_OVER_TIME_INTERVAL,
				CommonConst.TCD_BEFORE_OVER_TIME_INTERVAL_TIME));
	}
	
	/**
	 * 残業休憩支給対象単位時間
	 * @since	0.0.7
	 * @return	残業休憩支給対象単位時間（分）
	 * @throws Exception	例外処理が発生した場合
	 */
	public int getOverTimeUnitTime() throws Exception {
		return NumberUtil.getIntParam(part().mospcode().findTchange(CommonConst.TID_OVER_TIME_INTERVAL,
				CommonConst.TCD_OVER_TIME_UNIT_TIME));
	}
	
	/**
	 * 残業休憩時間
	 * @since	0.0.7
	 * @return	残業休憩支給対象単位時間毎に支給される残業休憩時間（分）
	 * @throws Exception	例外処理が発生した場合
	 */
	public int getOverTimeInterval() throws Exception {
		return NumberUtil.getIntParam(part().mospcode().findTchange(CommonConst.TID_OVER_TIME_INTERVAL,
				CommonConst.TCD_OVER_TIME_INTERVAL_TIME));
	}
	
	/**
	 * 基礎出勤簿情報生成
	 * @since	0.0.8
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日
	 * @return	基礎出勤簿情報DTO
	 * <p>
	 * 社員コード、日付、年、月、日のみセット
	 * </p>
	 */
	public static MSyukkinboDto createBaseSyukkinboInfo(String kCode, Date targetDate) {
		MSyukkinboDto dto = new MSyukkinboDto();
		dto.setKCode(kCode);
		dto.setHizuke(DateUtil.convDateFormatted(targetDate));
		dto.setNen(MospUtility.getYear(targetDate));
		dto.setTuki(MospUtility.getMonth(targetDate));
		dto.setHi(MospUtility.getDay(targetDate));
		return dto;
	}
	
	/**
	 * 出勤簿対象日取得
	 * @since	0.0.9
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日(yyyy/MM/dd)
	 * @return dto 対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public MSyukkinboDto getSyukkinboInfo(String kCode, String targetDate) throws Exception {
		return getMSyukkinboDao().findForKey(kCode, targetDate);
	}
	
	/**
	 * 出勤簿対象日取得
	 * @since	0.0.9
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日
	 * @return dto 対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public MSyukkinboDto getSyukkinboInfo(String kCode, Date targetDate) throws Exception {
		return getSyukkinboInfo(kCode, DateUtil.convDateFormatted(targetDate));
	}
	
	/**
	 * 出勤簿対象日行ロック
	 * @since	0.0.9
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日(yyyy/MM/dd)
	 * @return 				対象DTO(行ロック済み)
	 * @throws Exception	例外処理が発生した場合
	 */
	public MSyukkinboDto lockSyukkinboInfo(String kCode, String targetDate) throws Exception {
		return getMSyukkinboDao().findForUpdate(kCode, targetDate);
	}
	
	/**
	 * 出勤簿対象日行ロック
	 * @since	0.0.9
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日
	 * @return 				対象DTO(行ロック済み)
	 * @throws Exception	例外処理が発生した場合
	 */
	public MSyukkinboDto lockSyukkinboInfo(String kCode, Date targetDate) throws Exception {
		return lockSyukkinboInfo(kCode, DateUtil.convDateFormatted(targetDate));
	}
	
	/**
	 * 対象日出勤簿情報取得
	 * @since	0.0.9
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日(yyyy/MM/dd)
	 * @param isUpdate		行ロックフラグ
	 * @return	対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public MSyukkinboDto getSyukkinboInfo(String kCode, String targetDate, boolean isUpdate) throws Exception {
		if (isUpdate) {
			return lockSyukkinboInfo(kCode, targetDate);
		}
		return getSyukkinboInfo(kCode, targetDate);
	}
	
	/**
	 * 対象日出勤簿情報取得
	 * @since	0.0.9
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日
	 * @param isUpdate		行ロックフラグ
	 * @return	対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public MSyukkinboDto getSyukkinboInfo(String kCode, Date targetDate, boolean isUpdate) throws Exception {
		return getSyukkinboInfo(kCode, DateUtil.convDateFormatted(targetDate), isUpdate);
	}
	
	/**
	 * 予定簿対象日取得
	 * @since	0.0.9
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日(yyyy/MM/dd)
	 * @return dto 対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public MScheduleDto getScheduleInfo(String kCode, String targetDate) throws Exception {
		return getMScheduleDao().findForKey(kCode, targetDate);
	}
	
	/**
	 * 予定簿対象日取得
	 * @since	0.0.9
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日
	 * @return dto 対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public MScheduleDto getScheduleInfo(String kCode, Date targetDate) throws Exception {
		return getScheduleInfo(kCode, DateUtil.convDateFormatted(targetDate));
	}
	
	/**
	 * 予定簿対象日行ロック
	 * @since	0.0.9
	 * <p>	2009/04/21	m.yoshida	追加	</p>
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日(yyyy/MM/dd)
	 * @return				対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public MScheduleDto lockScheduleInfo(String kCode, String targetDate) throws Exception {
		return getMScheduleDao().findForUpdate(kCode, targetDate);
	}
	
	/**
	 * 予定簿対象日取得
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日(yyyy/MM/dd)
	 * @param isUpdate 		行ロックフラグ
	 * @return				対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public MScheduleDto getScheduleInfo(String kCode, String targetDate, boolean isUpdate) throws Exception {
		if (isUpdate) {
			return lockScheduleInfo(kCode, targetDate);
		}
		return getScheduleInfo(kCode, targetDate);
	}
	
	/**
	 * 予定簿対象日取得
	 * @param kCode			対象社員コード
	 * @param targetDate	対象年月日
	 * @param isUpdate 		行ロックフラグ
	 * @return				対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public MScheduleDto getScheduleInfo(String kCode, Date targetDate, boolean isUpdate) throws Exception {
		if (isUpdate) {
			return lockScheduleInfo(kCode, DateUtil.convDateFormatted(targetDate));
		}
		return getScheduleInfo(kCode, targetDate);
	}
	
	/**
	 * 仮出勤簿情報生成
	 * @since	0.0.10
	 * @param kCode				対象社員コード
	 * @param targetDate		対象年月日
	 * @param startTime			開始時刻(HH:mm)
	 * @param quitTime			終了時刻(HH:mm)
	 * @param kinmu				勤務形態
	 * @param isStartHalf		出勤半休区分
	 * @param isQuitHalf		退勤半休区分
	 * @param isWorkOnHoliday	休出判断
	 * @return	仮出勤簿情報
	 */
	public static MSyukkinboDto createPreSyukkinboInfo(String kCode, Date targetDate, String startTime,
			String quitTime, String kinmu, boolean isStartHalf, boolean isQuitHalf, boolean isWorkOnHoliday) {
		// 基礎出勤簿情報生成
		MSyukkinboDto dto = createBaseSyukkinboInfo(kCode, targetDate);
		// 勤務形態
		dto.setKinmu(kinmu);
		// 出勤時刻
		if (StringUtil.isNotNull(startTime)) {
			dto.setSyJikoku(startTime);
			dto.setSyTimes(DateUtil.getDateTime(DateUtil.getNowDate()));
		}
		// 退勤時刻
		if (StringUtil.isNotNull(quitTime)) {
			dto.setTaJikoku(quitTime);
			dto.setTaTimes(DateUtil.getDateTime(DateUtil.getNowDate()));
		}
		// 出勤半休
		if (isStartHalf) {
			dto.setSHankyuKb(CommonConst.NUM_START_HALF_HOLIDAY_FLAG_ON);
		}
		// 退勤半休
		if (isQuitHalf) {
			dto.setTHankyuKb(CommonConst.NUM_QUIT_HALF_HOLIDAY_FLAG_ON);
		}
		// 休出判断
		if (isWorkOnHoliday) {
			dto.setKyusyuKb(CommonConst.NUM_WORK_ON_HOLIDAY_FLAG_ON);
		}
		dto.setUpdtTimes(DateUtil.getDateTime(DateUtil.getNowDate()));
		return dto;
	}
	
	/**
	 * 予定簿情報の生成
	 * @since	0.0.11
	 * @param userBasis		対象社員基本情報
	 * @param targetDate	対象年月日
	 * @param shiftCode		対象勤務形態コード
	 * @return	生成予定簿情報
	 * @throws Exception	例外処理が発生した場合
	 */
	public MScheduleDto createScheduleInfo(HumanBasisDtoInterface userBasis, Date targetDate, String shiftCode)
			throws Exception {
		MScheduleDto dto = new MScheduleDto();
		addWorkTypeInfo(dto, userBasis, targetDate, shiftCode);
		return dto;
	}
	
	/**
	 * 勤務携帯情報を設定
	 * @param dto 対象DTO
	 * @param userBasis		対象社員基本情報
	 * @param targetDate	対象年月日
	 * @param shiftCode		対象勤務形態コード
	 * @throws Exception 	例外処理が発生した場合
	 */
	public void addWorkTypeInfo(KintaiCommonDtoInterface dto, HumanBasisDtoInterface userBasis, Date targetDate,
			String shiftCode) throws Exception {
		if (VariousUtil.isNotNull(dto)) {
			dto.setKCode(userBasis.getKCode());
			dto.setHizuke(DateUtil.convDateFormatted(targetDate));
			dto.setNen(MospUtility.getYear(targetDate));
			dto.setTuki(MospUtility.getMonth(targetDate));
			dto.setHi(MospUtility.getDay(targetDate));
			dto.setSyozoku(userBasis.getSCode());
			dto.setUpdtTimes(DateUtil.getDateTime(DateUtil.getNowDate()));
			dto.setSnRiyuu(CommonConst.NUM_ATTENDANCE_REQUEST);
			if (StringUtil.isNotNull(shiftCode)) {
				// 休暇の場合
				if (isHoliday(shiftCode)) {
					dto.setKinmu(CommonConst.ATTENDANCE_TYPE_HOLIDAY);
				} else if (isWeekHoliday(shiftCode)) {
					// 週休の場合
					dto.setKinmu(CommonConst.ATTENDANCE_TYPE_WEEK_HOLIDAY);
				} else if (isOfficialHoliday(shiftCode)) {
					// 法定休日対応
					dto.setKinmu(CommonConst.ATTENDANCE_TYPE_OFFICIAL_HOLIDAY);
				} else {
					CmWorkTypeDto workTypeDto = part().worktype().getWorkTypeInfo(shiftCode);
					dto.setKinmu(workTypeDto.getShiftCode());
					dto.setSyJikoku(TimeUtil.convIntegerTimeToStringTime(workTypeDto.getStartTime()));
					dto.setSyTimes(DateUtil.getDateTime(DateUtil.getNowDate()));
					dto.setTaJikoku(TimeUtil.convIntegerTimeToStringTime(workTypeDto.getQuitTime()));
					dto.setKinmuJi(workTypeDto.getWorkTime());
					dto.setKyukeiJi(workTypeDto.getBreakTime());
					dto.setTaTimes(DateUtil.getDateTime(DateUtil.getNowDate()));
				}
			}
		}
	}
	
	/**
	 * 勤務形態名称取得（週休、休暇理由を含む）
	 * @since	0.0.12
	 * @param dto	対象DTO
	 * @param addTime	勤務形態時刻情報表示判断
	 * @return	勤務形態名称
	 * @throws Exception	例外処理が発生した場合
	 */
	public String getWorkTypeNameForKinmu(KintaiCommonDtoInterface dto, boolean addTime) throws Exception {
		return getWorkTypeNameForKinmu(dto.getKinmu(), dto.getKKRiyuu(), addTime);
	}
	
	/**
	 * 勤務形態名称取得（週休、休暇理由を含む）
	 * @since	0.0.12
	 * @param kinmu		対象勤務形態コード
	 * @param kkRiyuu	対象休暇理由コード
	 * @param addTime	勤務形態時刻情報表示判断
	 * @return	勤務形態名称
	 * @throws Exception	例外処理が発生した場合
	 */
	public String getWorkTypeNameForKinmu(String kinmu, String kkRiyuu, boolean addTime) throws Exception {
		if (StringUtil.isNotNull(kinmu)) {
			// 休暇の場合
			if (isHoliday(kinmu)) {
				return part().mospcode().getHolidayName(kkRiyuu);
			}
			// 勤務形態、所定休日、法定休日
			return part().worktype().getWorkTypeName(kinmu, addTime);
		}
		return kinmu;
	}
	
	/**
	 * コードを名称に変換(勤務形態、休出区分、遅刻理由、遅刻証明書、早退理由、早退証明書)
	 * @since	0.0.13
	 * @param dto			対象DTO
	 * @throws Exception	例外処理が発生した場合
	 */
	public void replaceCodeToName(KintaiCommonDtoInterface dto) throws Exception {
		// 勤務形態
		dto.setKinmu(getWorkTypeNameForKinmu(dto, true));
		// 休出区分
		dto.setKyusyuKb(part().mospcode().getTName(CommonConst.TID_WORK_ON_HOLIDAY_TYPE, dto.getKyusyuKb()));
		// 遅刻理由
		dto.setTiRiyuu(part().mospcode().getTName(CommonConst.TID_LATE_REASON, dto.getTiRiyuu()));
		// 遅刻証明書
		dto.setTiSyoumei(part().mospcode().getTName(CommonConst.TID_LATE_CERTIFICATE, dto.getTiSyoumei()));
		// 早退理由
		dto.setSoRiyuu(part().mospcode().getTName(CommonConst.TID_LEAVE_EARLY_REASON, dto.getSoRiyuu()));
		// 早退証明書
		dto.setSoSyoumei(part().mospcode().getTName(CommonConst.TID_LEAVE_EARLY_CERTIFICATE, dto.getSoSyoumei()));
	}
	
	/**
	 * 曜日フォント色設定
	 * @since	0.0.14
	 * @param targetDate	対象年月日
	 * @return	フォント色のクラス名
	 * @throws Exception	例外処理が発生した場合
	 */
	public String getDayOfWeekColorClass(Date targetDate) throws Exception {
		String className = CommonConst.CSS_CLASS_NORMAL_SPAN;
		if (DateUtil.isDayOfWeek(targetDate, Calendar.SATURDAY)) {
			className = CommonConst.CSS_CLASS_BLUE_SPAN;
		}
		if (DateUtil.isDayOfWeek(targetDate, Calendar.SUNDAY) || part().jpholiday().isPublicHoliday(targetDate)) {
			className = CommonConst.CSS_CLASS_RED_SPAN;
		}
		return className;
	}
	
	/**
	 * 勤怠入力丸め処理判断
	 * @return
	 * <p>
	 * 丸め処理を勤怠入力時に行う場合true、そうでない場合false
	 * </p>
	 * @throws Exception 　例外処理が発生した場合
	 */
	public boolean isRoundNumberDaily() throws Exception {
		return StringUtil.isFlagOff(part().mospcode().getRoundNumberProcess());
	}
	
	/**
	 * 勤怠集計丸め処理判断
	 * @return
	 * <p>
	 * 丸め処理を勤怠集計時に行う場合true、そうでない場合false
	 * </p>
	 * @throws Exception　例外処理が発生した場合
	 */
	public boolean isRoundNumberMonthly() throws Exception {
		return StringUtil.isFlagOn(part().mospcode().getRoundNumberProcess());
	}
	
	/**
	 * 法定休日判断
	 * @param code 対象コード
	 * @return
	 * <p>
	 * 法定休日のコードである場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isOfficialHoliday(String code) {
		return CommonConst.ATTENDANCE_TYPE_OFFICIAL_HOLIDAY.equals(code);
	}
	
	/**
	 * 法定休日判断
	 * @param dto 対象DTO
	 * @return
	 * <p>
	 * 法定休日のコードである場合true、そうでない場合false
	 * </p>
	 */
	public static boolean isOfficialHoliday(KintaiCommonDtoInterface dto) {
		return isOfficialHoliday(dto.getKinmu());
	}
	
	/**
	 * 月60時間時間外による代休（全休）の判断
	 * @param dto 対象DTO
	 * @return
	 * <p>
	 * 月60時間時間外による代休（全休）の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isOverTimeSubHolidayAll(KintaiCommonDtoInterface dto) {
		if (isHoliday(dto)) {
			return HolidayRequestPart.isSubHoliday(dto.getKKRiyuu());
		}
		return false;
	}
	
	/**
	 * 月60時間時間外による代休（前半休）の判断
	 * @param dto 対象DTO
	 * @return
	 * <p>
	 * 月60時間時間外による代休（前半休）の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isOverTimeSubHolidayStart(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return CommonConst.CODE_SUB_HOLIDAY_HALF_FLAG.equals(dto.getSHankyuKb());
		}
		return false;
	}
	
	/**
	 * 月60時間時間外による代休（後半休）の判断
	 * @param dto 対象DTO
	 * @return
	 * <p>
	 * 月60時間時間外による代休（後半休）の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isOverTimeSubHolidayQuit(KintaiCommonDtoInterface dto) {
		if (VariousUtil.isNotNull(dto)) {
			return CommonConst.CODE_SUB_HOLIDAY_HALF_FLAG.equals(dto.getTHankyuKb());
		}
		return false;
	}
	
	/**
	 * 月60時間時間外による代休（半休）の判断
	 * @param dto 対象DTO
	 * @return
	 * <p>
	 * 月60時間時間外による代休（半休）の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isOverTimeSubHolidayHalf(KintaiCommonDtoInterface dto) {
		return isOverTimeSubHolidayStart(dto) || isOverTimeSubHolidayQuit(dto);
	}
	
	/**
	 * 休暇理由1判断
	 * @param kkRiyuu 対象休暇理由コード
	 * @return
	 * <p>
	 * 休暇理由コードが「1」の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isParticularHoliday(String kkRiyuu) {
		return CommonConst.CODE_HOLIDAY_REASON_PARTICULAR.equals(kkRiyuu);
	}
	
	/**
	 * 休暇理由2判断
	 * @param kkRiyuu 対象休暇理由コード
	 * @return
	 * <p>
	 * 休暇理由コードが「2」の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isAbsence(String kkRiyuu) {
		return CommonConst.CODE_HOLIDAY_REASON_ABSENCE.equals(kkRiyuu);
	}
	
	/**
	 * 休暇理由3判断
	 * @param kkRiyuu 対象休暇理由コード
	 * @return
	 * <p>
	 * 休暇理由コードが「3」の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isMedical(String kkRiyuu) {
		return CommonConst.CODE_HOLIDAY_REASON_MEDICAL.equals(kkRiyuu);
	}
	
	/**
	 * 休暇理由4判断
	 * @param kkRiyuu 対象休暇理由コード
	 * @return
	 * <p>
	 * 休暇理由コードが「4」の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isCompensation(String kkRiyuu) {
		return CommonConst.CODE_HOLIDAY_REASON_COMPENSATION.equals(kkRiyuu);
	}
	
	/**
	 * 休暇理由5判断
	 * @param kkRiyuu 対象休暇理由コード
	 * @return
	 * <p>
	 * 休暇理由コードが「5」の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isTransfer(String kkRiyuu) {
		return CommonConst.CODE_HOLIDAY_REASON_TRANSFER.equals(kkRiyuu);
	}
	
	/**
	 * 休暇理由6判断
	 * @param kkRiyuu 対象休暇理由コード
	 * @return
	 * <p>
	 * 休暇理由コードが「6」の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isHolidayReason6(String kkRiyuu) {
		return CommonConst.CODE_HOLIDAY_REASON_6.equals(kkRiyuu);
	}
	
	/**
	 * 休暇理由7判断
	 * @param kkRiyuu 対象休暇理由コード
	 * @return
	 * <p>
	 * 休暇理由コードが「7」の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isHolidayReason7(String kkRiyuu) {
		return CommonConst.CODE_HOLIDAY_REASON_7.equals(kkRiyuu);
	}
	
	/**
	 * 休暇理由8判断
	 * @param kkRiyuu 対象休暇理由コード
	 * @return
	 * <p>
	 * 休暇理由コードが「8」の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isHolidayReason8(String kkRiyuu) {
		return CommonConst.CODE_HOLIDAY_REASON_8.equals(kkRiyuu);
	}
	
	/**
	 * 休暇理由9判断
	 * @param kkRiyuu 対象休暇理由コード
	 * @return
	 * <p>
	 * 休暇理由コードが「9」の場合true、そうでない場合false。
	 * </p>
	 */
	public static boolean isHolidayReason9(String kkRiyuu) {
		return CommonConst.CODE_HOLIDAY_REASON_9.equals(kkRiyuu);
	}
	
	/**
	 * 対象期間の残業時間合計数
	 * @param kCode 対象社員コード
	 * @param startDate 開始年月日
	 * @param endDate 終了年月日
	 * @return 対象期間の残業時間合計(分)
	 * @throws Exception 　例外処理が発生した場合
	 */
	public int getOverTimeForPeriod(String kCode, Date startDate, Date endDate) throws Exception {
		return getMSyukkinboDao().findForOverTimeSum(kCode, DateUtil.convDateFormatted(startDate),
				DateUtil.convDateFormatted(endDate));
	}
	
	/**
	 * @param kCode 対象社員コード
	 * @param startDate 開始日
	 * @param endDate 終了日
	 * @return 対象社員の日付一覧による予定簿のマップ
	 * @throws Exception 例外処理が発生した場合
	 */
	public Map<Date, MScheduleDto> getScheduleMap(String kCode, Date startDate, Date endDate) throws Exception {
		Map<Date, MScheduleDto> map = new TreeMap<Date, MScheduleDto>();
		Calendar cal = Calendar.getInstance();
		cal.setTime(startDate);
		while (cal.getTime().compareTo(endDate) <= 0) {
			map.put(cal.getTime(), null);
			cal.add(Calendar.DATE, 1);
		}
		List<MScheduleDto> list = getScheduleList(kCode, startDate, endDate);
		for (MScheduleDto dto : list) {
			map.put(DateUtil.convStringDateToDate(dto.getHizuke()), dto);
		}
		return map;
	}
	
	/**
	 * @param kCode 対象社員コード
	 * @param startDate 開始日
	 * @param endDate 終了日
	 * @return 対象社員の日付一覧による予定簿のマップ
	 * @throws Exception 例外処理が発生した場合
	 */
	public Map<Date, MSyukkinboDto> getAttendanceMap(String kCode, Date startDate, Date endDate) throws Exception {
		Map<Date, MSyukkinboDto> map = new TreeMap<Date, MSyukkinboDto>();
		Calendar cal = Calendar.getInstance();
		cal.setTime(startDate);
		while (cal.getTime().compareTo(endDate) <= 0) {
			map.put(cal.getTime(), null);
			cal.add(Calendar.DATE, 1);
		}
		List<MSyukkinboDto> list = getAttendanceList(kCode, startDate, endDate);
		for (MSyukkinboDto dto : list) {
			map.put(DateUtil.convStringDateToDate(dto.getHizuke()), dto);
		}
		return map;
	}
	
}
