/*
 * 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 Affero General Public License
 * as published by the Free Software Foundation, either version 3
 * 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 Affero General Public License for more details.
 * 
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package jp.mosp.time.input.action;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import jp.mosp.framework.base.BaseVo;
import jp.mosp.framework.base.MospException;
import jp.mosp.framework.constant.MospConst;
import jp.mosp.framework.utils.DateUtility;
import jp.mosp.framework.utils.MospUtility;
import jp.mosp.platform.bean.workflow.WorkflowRegistBeanInterface;
import jp.mosp.platform.constant.PlatformConst;
import jp.mosp.platform.constant.PlatformMessageConst;
import jp.mosp.platform.dto.workflow.WorkflowCommentDtoInterface;
import jp.mosp.platform.dto.workflow.WorkflowDtoInterface;
import jp.mosp.time.base.TimeAction;
import jp.mosp.time.base.TimeBean;
import jp.mosp.time.bean.ApplicationReferenceBeanInterface;
import jp.mosp.time.bean.AttendanceCalcBeanInterface;
import jp.mosp.time.bean.AttendanceListRegistBeanInterface;
import jp.mosp.time.bean.AttendanceRegistBeanInterface;
import jp.mosp.time.bean.GoOutRegistBeanInterface;
import jp.mosp.time.bean.RequestUtilBeanInterface;
import jp.mosp.time.bean.ScheduleReferenceBeanInterface;
import jp.mosp.time.bean.TimeSettingReferenceBeanInterface;
import jp.mosp.time.bean.WorkTypeReferenceBeanInterface;
import jp.mosp.time.constant.TimeConst;
import jp.mosp.time.constant.TimeMessageConst;
import jp.mosp.time.dto.settings.AllowanceDtoInterface;
import jp.mosp.time.dto.settings.ApplicationDtoInterface;
import jp.mosp.time.dto.settings.AttendanceCorrectionDtoInterface;
import jp.mosp.time.dto.settings.AttendanceDtoInterface;
import jp.mosp.time.dto.settings.DifferenceRequestDtoInterface;
import jp.mosp.time.dto.settings.GoOutDtoInterface;
import jp.mosp.time.dto.settings.HolidayRequestDtoInterface;
import jp.mosp.time.dto.settings.OvertimeRequestDtoInterface;
import jp.mosp.time.dto.settings.RestDtoInterface;
import jp.mosp.time.dto.settings.ScheduleDtoInterface;
import jp.mosp.time.dto.settings.SubHolidayRequestDtoInterface;
import jp.mosp.time.dto.settings.SubstituteDtoInterface;
import jp.mosp.time.dto.settings.TimeSettingDtoInterface;
import jp.mosp.time.dto.settings.WorkOnHolidayRequestDtoInterface;
import jp.mosp.time.dto.settings.WorkTypeDtoInterface;
import jp.mosp.time.dto.settings.WorkTypeItemDtoInterface;
import jp.mosp.time.input.vo.AttendanceCardVo;

/**
 * 日々勤怠の詳細情報確認とその編集、更新を行う。<br>
 * <br>
 * 以下のコマンドを扱う。<br>
 * <ul><li>
 * {@link #CMD_SHOW}
 * </li><li>
 * {@link #CMD_SELECT_SHOW}
 * </li><li>
 * {@link #CMD_SEARCH}
 * </li><li>
 * {@link #CMD_RE_SEARCH}
 * </li><li>
 * {@link #CMD_DRAFT}
 * </li><li>
 * {@link #CMD_APPLI}
 * </li><li>
 * {@link #CMD_TRANSFER}
 * </li></ul>
 */
public class AttendanceCardAction extends TimeAction {
	
	/**
	 * 表示コマンド。<br>
	 * <br>
	 * 現在ログインしているユーザの日々勤怠の詳細情報表示画面へ遷移する。<br>
	 */
	public static final String	CMD_SHOW							= "TM1200";
	
	/**
	 * 選択表示コマンド。<br>
	 * <br>
	 * 日々勤怠の詳細情報表示画面へ遷移する。<br>
	 */
	public static final String	CMD_SELECT_SHOW						= "TM1201";
	
	/**
	 * 検索コマンド。<br>
	 * <br>
	 * 操作者の指定にしたがって表示する対象年月を変更する。
	 * 前月・翌月ボタンといったものは現在表示している年月を基に画面遷移を行う。<br>
	 */
	public static final String	CMD_SEARCH							= "TM1202";
	
	/**
	 * 再表示コマンド。<br>
	 * <br>
	 * 一度この画面を表示してからパンくずリスト等で再度遷移する場合は保持していた検索条件で検索を行って再表示する。<br>
	 */
	public static final String	CMD_RE_SEARCH						= "TM1203";
	
	/**
	 * 下書きコマンド。<br>
	 * <br>
	 * 編集した入力欄の内容を勤怠情報テーブルに登録し、下書情報として保存する。<br>
	 */
	public static final String	CMD_DRAFT							= "TM1204";
	
	/**
	 * 申請コマンド。<br>
	 * <br>
	 * 編集した入力欄の内容を勤怠情報テーブルに登録し、勤怠申請を行う。<br>
	 */
	public static final String	CMD_APPLI							= "TM1205";
	
	/**
	 * 画面遷移コマンド。<br>
	 * <br>
	 * 現在表示している画面から、対象個人ID、対象日等をMosP処理情報に設定し、画面遷移する。<br>
	 */
	public static final String	CMD_TRANSFER						= "TM1208";
	
	/**
	 * 勤怠詳細画面メニューキー。<br>
	 * ポータル画面から遷移した場合に、範囲設定をするために用いる。<br>
	 */
	public static final String	MENU_ATTENDANCE_CARD				= "AttendanceCard";
	
	/**
	 * パラメータID(勤怠詳細追加JSP)。
	 */
	public static final String	PRM_ATTENDANCE_EXTRA_JSP			= "prmAttendanceExtraJsp";
	
	/**
	 * 申請モード(休日承認済)。
	 */
	public static final String	MODE_APPLICATION_COMPLETED_HOLIDAY	= "completedHoliday";
	

	/**
	 * {@link TimeAction#TimeAction()}を実行する。<br>
	 */
	public AttendanceCardAction() {
		super();
		// パンくずリスト用コマンド設定
		topicPathCommand = CMD_RE_SEARCH;
	}
	
	@Override
	protected BaseVo getSpecificVo() {
		return new AttendanceCardVo();
	}
	
	@Override
	public void action() throws MospException {
		// 追加JSP設定
		setAttendanceExtraJsp();
		// コマンド毎の処理
		if (mospParams.getCommand().equals(CMD_SHOW)) {
			// 表示
			prepareVo(false, false);
			show();
		} else if (mospParams.getCommand().equals(CMD_SELECT_SHOW)) {
			// 選択表示
			prepareVo(false, false);
			select();
		} else if (mospParams.getCommand().equals(CMD_SEARCH)) {
			// 検索
			prepareVo();
			search();
		} else if (mospParams.getCommand().equals(CMD_RE_SEARCH)) {
			// 再表示
			prepareVo(true, false);
			search();
		} else if (mospParams.getCommand().equals(CMD_DRAFT)) {
			// 下書き
			prepareVo();
			draft();
		} else if (mospParams.getCommand().equals(CMD_APPLI)) {
			// 申請
			prepareVo();
			appli();
		} else if (mospParams.getCommand().equals(CMD_TRANSFER)) {
			// 遷移
			prepareVo(true, false);
			transfer();
		}
	}
	
	/**
	 * 勤怠詳細追加JSPを設定する。
	 */
	protected void setAttendanceExtraJsp() {
		// アドオン機能などで処理
	}
	
	/**
	 * 初期表示処理を行う。<br>
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void show() throws MospException {
		// ログインユーザの個人IDを取得
		String personalId = mospParams.getUser().getPersonalId();
		// システム日付を取得
		Date targetDate = getSystemDate();
		// プルダウンの設定
		setPulldown();
		// 勤怠詳細情報設定
		setAttendaneCardInfo(personalId, targetDate);
	}
	
	/**
	 * 選択表示処理を行う。<br>
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void select() throws MospException {
		// 範囲設定確認(ポータル画面から遷移してくる場合)
		checkRangeMap(MENU_ATTENDANCE_CARD);
		// リクエストから個人ID及び対象日を取得
		String personalId = getTargetPersonalId();
		Date targetDate = getTargetDate();
		// 個人ID確認
		if (personalId == null || personalId.isEmpty()) {
			// ログインユーザの個人IDを取得
			personalId = mospParams.getUser().getPersonalId();
		}
		// 対象日確認
		if (targetDate == null) {
			// 譲渡有効日を取得
			targetDate = getDate(getTransferredActivateDate());
		}
		// プルダウンの設定
		setPulldown();
		// 勤怠詳細情報設定
		setAttendaneCardInfo(personalId, targetDate);
	}
	
	/**
	 * 日付の更新後、該当日付の勤怠詳細を取得する。<br>
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void search() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// VOから個人ID取得
		String personalId = vo.getPersonalId();
		// VOから対象日取得
		Date targetDate = vo.getTargetDate();
		// 日付操作確認
		if (getTransferredGenericCode() == null) {
			// VOから対象日取得
			targetDate = vo.getTargetDate();
		} else if (getTransferredGenericCode().equals(TimeConst.CODE_DATE_DECREMENT)) {
			// 対象日 - 1
			targetDate = DateUtility.addDay(targetDate, -1);
		} else if (getTransferredGenericCode().equals(TimeConst.CODE_DATE_INCREMENT)) {
			// 対象日 + 1
			targetDate = DateUtility.addDay(targetDate, 1);
		} else if (getTransferredGenericCode().equals(TimeConst.CODE_DATE_RESET)) {
			// システム日付
			targetDate = DateUtility.getSystemDate();
		}
		// 勤怠詳細情報設定
		setAttendaneCardInfo(personalId, targetDate);
	}
	
	/**
	 * 下書処理を行う。<br>
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void draft() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		AttendanceCalcBeanInterface calc = time().attendanceCalc();
		AttendanceRegistBeanInterface regist = time().attendanceRegist();
		// 個人ID、対象日、勤務回数取得
		String personalId = vo.getPersonalId();
		Date date = vo.getTargetDate();
		int timesWork = TimeBean.TIMES_WORK_DEFAULT;
		// DTOの準備
		// 勤怠データ設定
		AttendanceDtoInterface dto = timeReference().attendance().findForKey(personalId, date, timesWork);
		if (dto == null) {
			dto = time().attendanceRegist().getInitDto();
		}
		// VO(編集項目)の値をDTOに設定
		setAttendanceDtoFields(dto);
		// 始業終業時刻自動計算
		calc.calcStartEndTime(dto, true);
		// 休憩データ設定
		List<RestDtoInterface> restList = new ArrayList<RestDtoInterface>();
		setRestFields(restList, dto);
		// 外出データ設定
		// 公用
		List<GoOutDtoInterface> goOutPublicList = new ArrayList<GoOutDtoInterface>();
		// 私用 
		List<GoOutDtoInterface> goOutPrivateList = new ArrayList<GoOutDtoInterface>();
		setGoOutDtoFields(goOutPublicList, goOutPrivateList, dto.getStartTime(), dto.getEndTime());
		chkRest(dto);
		chkPrivateGoOut(dto);
		if (mospParams.hasErrorMessage()) {
			// 登録失敗メッセージ設定
			addInsertFailedMessage();
			return;
		}
		// 自動計算処理
		calc.attendanceCalc(dto, restList, goOutPublicList, goOutPrivateList);
		// 追加処理
		setGeneralDtoFields();
		// 妥当性チェック
		regist.validate(dto);
		// 申請の相関チェック
		regist.checkDraft(dto);
		// 登録クラスの取得
		WorkflowRegistBeanInterface workflowRegist = platform().workflowRegist();
		// ワークフローの設定
		WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(dto.getWorkflow());
		if (workflowDto == null) {
			workflowDto = workflowRegist.getInitDto();
			workflowDto.setFunctionCode(TimeConst.CODE_FUNCTION_WORK_MANGE);
		}
		workflowRegist.setDtoApproverIds(workflowDto, getSelectApproverIds());
		// 登録後ワークフローの取得
		workflowDto = workflowRegist.draft(workflowDto, dto.getPersonalId(), dto.getWorkDate(),
				PlatformConst.WORKFLOW_TYPE_TIME);
		if (workflowDto != null) {
			// ワークフローコメント登録
			platform().workflowCommentRegist().addComment(
					workflowDto,
					mospParams.getUser().getPersonalId(),
					mospParams.getProperties().getMessage(PlatformMessageConst.MSG_PROCESS_SUCCEED,
							new String[]{ mospParams.getName("WorkPaper") }));
			// ワークフロー番号セット
			dto.setWorkflow(workflowDto.getWorkflow());
			// 勤怠データ登録
			regist.regist(dto);
			// 休憩データ登録
			for (int i = 0; i < restList.size(); i++) {
				time().restRegist().regist(restList.get(i));
			}
			// 外出データ登録
			for (int i = 0; i < goOutPublicList.size(); i++) {
				time().goOutRegist().regist(goOutPublicList.get(i));
			}
			for (int i = 0; i < goOutPrivateList.size(); i++) {
				time().goOutRegist().regist(goOutPrivateList.get(i));
			}
		}
		// 登録結果確認
		if (mospParams.hasErrorMessage()) {
			// 登録失敗メッセージ設定
			addInsertFailedMessage();
			return;
		}
		// コミット
		commit();
		// 下書成功メッセージ設定
		addDraftMessage();
		// 勤怠詳細情報設定
		setAttendaneCardInfo(vo.getPersonalId(), vo.getTargetDate());
		// 編集モード設定
		vo.setModeCardEdit(TimeConst.MODE_APPLICATION_DRAFT);
	}
	
	/**
	 * 申請処理を行う。<br>
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void appli() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		AttendanceCalcBeanInterface calc = time().attendanceCalc();
		// 登録クラスの取得
		AttendanceRegistBeanInterface regist = time().attendanceRegist();
		AttendanceListRegistBeanInterface listRegist = time().attendanceListRegist();
		WorkflowRegistBeanInterface workflowRegist = platform().workflowRegist();
		// 個人ID、対象日、勤務回数取得
		String personalId = vo.getPersonalId();
		Date date = vo.getTargetDate();
		// デフォルト勤務回数
		int timesWork = TimeBean.TIMES_WORK_DEFAULT;
		// 変更前データ取得
		// 勤怠データ
		AttendanceDtoInterface oldAttendance = timeReference().attendance().findForKey(personalId, date, timesWork);
		if (oldAttendance == null) {
			oldAttendance = regist.getInitDto();
		}
		// 休暇データ
		List<RestDtoInterface> oldRestList = timeReference().rest().getRestList(personalId, date, timesWork);
		if (oldRestList == null) {
			oldRestList = new ArrayList<RestDtoInterface>();
		}
		// 外出データ
		List<GoOutDtoInterface> oldGoOutPublicList = timeReference().goOut().getGoOutList(personalId, date, timesWork,
				1);
		if (oldGoOutPublicList == null) {
			oldGoOutPublicList = new ArrayList<GoOutDtoInterface>();
		}
		// 外出データ
		List<GoOutDtoInterface> oldGoOutPrivateList = timeReference().goOut().getGoOutList(personalId, date, timesWork,
				2);
		if (oldGoOutPrivateList == null) {
			oldGoOutPrivateList = new ArrayList<GoOutDtoInterface>();
		}
		// 勤怠データ設定
		AttendanceDtoInterface dto = timeReference().attendance().findForKey(personalId, date, timesWork);
		if (dto == null) {
			dto = regist.getInitDto();
		}
		// VO(編集項目)の値をDTOに設定
		setAttendanceDtoFields(dto);
		// 始業終業時刻自動計算
		calc.calcStartEndTime(dto, true);
		// 休憩データ設定
		List<RestDtoInterface> restList = new ArrayList<RestDtoInterface>();
		setRestFields(restList, dto);
		// 外出データ設定
		// 公用
		List<GoOutDtoInterface> goOutPublicList = new ArrayList<GoOutDtoInterface>();
		// 私用
		List<GoOutDtoInterface> goOutPrivateList = new ArrayList<GoOutDtoInterface>();
		setGoOutDtoFields(goOutPublicList, goOutPrivateList, dto.getStartTime(), dto.getEndTime());
		chkRest(dto);
		chkPrivateGoOut(dto);
		if (mospParams.hasErrorMessage()) {
			// 登録失敗メッセージ設定
			addInsertFailedMessage();
			return;
		}
		// 時間帯の重複チェック処理
		chkDuplRest();
		if (mospParams.hasErrorMessage()) {
			// 登録失敗メッセージ設定
			addInsertFailedMessage();
			return;
		}
		// 自動計算処理
		calc.attendanceCalc(dto, restList, goOutPublicList, goOutPrivateList);
		// 追加処理
		setGeneralDtoFields();
		// 妥当性チェック
		regist.validate(dto);
		// 申請の相関チェック
		regist.checkAppli(dto);
		// 私用外出時間チェック
		regist.checkPrivateGoOut(dto, restList, goOutPrivateList);
		// 休憩データ登録
		for (RestDtoInterface restDto : restList) {
			time().restRegist().regist(restDto);
		}
		// 外出データ登録
		for (GoOutDtoInterface goOutDto : goOutPublicList) {
			time().goOutRegist().regist(goOutDto);
		}
		for (GoOutDtoInterface goOutDto : goOutPrivateList) {
			time().goOutRegist().regist(goOutDto);
		}
		// 修正履歴を登録
		listRegist.registCorrection(dto, oldRestList, oldGoOutPublicList, oldGoOutPrivateList);
		// ワークフローの設定
		WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(dto.getWorkflow());
		if (workflowDto == null) {
			workflowDto = workflowRegist.getInitDto();
			workflowDto.setFunctionCode(TimeConst.CODE_FUNCTION_WORK_MANGE);
		}
		// 承認者個人IDを設定
		workflowRegist.setDtoApproverIds(workflowDto, getSelectApproverIds());
		// 登録後ワークフローの取得
		workflowDto = workflowRegist.appli(workflowDto, dto.getPersonalId(), dto.getWorkDate(),
				PlatformConst.WORKFLOW_TYPE_TIME, null);
		if (workflowDto != null) {
			// 申請の相関チェック
			regist.checkApprover(dto, workflowDto);
			// ワークフロー番号セット
			dto.setWorkflow(workflowDto.getWorkflow());
			// 勤怠データ登録
			regist.regist(dto);
			// 代休データの設定
			listRegist.registSubHoliday(dto);
		}
		// 登録結果確認
		if (mospParams.hasErrorMessage()) {
			// 登録失敗メッセージ設定
			addInsertFailedMessage();
			return;
		}
		// コミット
		commit();
		// 申請成功メッセージ設定
		addAppliMessage();
		// 残業申請督促確認
		listRegist.checkOvertime(dto);
		// 勤怠詳細情報設定
		setAttendaneCardInfo(vo.getPersonalId(), vo.getTargetDate());
		// 編集モード設定
		vo.setModeCardEdit(TimeConst.MODE_APPLICATION_APPLIED);
	}
	
	/**
	 * 対象個人ID、対象日等をMosP処理情報に設定し、
	 * 譲渡Actionクラス名に応じて連続実行コマンドを設定する。<br>
	 */
	protected void transfer() {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 譲渡Actionクラス名取得
		String actionName = getTransferredAction();
		// MosP処理情報に対象個人IDを設定
		setTargetPersonalId(vo.getPersonalId());
		// MosP処理情報に対象日を設定
		setTargetDate(vo.getTargetDate());
		// 譲渡Actionクラス名毎に処理
		if (actionName.equals(OvertimeRequestAction.class.getName())) {
			if (getTransferredActivateDate() == null || getTransferredType() == null) {
				// 残業申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(OvertimeRequestAction.CMD_SELECT_SHOW);
			} else {
				// 残業申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(OvertimeRequestAction.CMD_EDIT_MODE);
			}
		} else if (actionName.equals(HolidayRequestAction.class.getName())) {
			if (getTransferredActivateDate() == null || getTransferredHolidayType1() == null
					|| getTransferredHolidayType2() == null || getTransferredHolidayRange() == null
					|| getTransferredStartTime() == null) {
				// 休暇申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(HolidayRequestAction.CMD_SELECT_SHOW);
			} else {
				// 休暇申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(HolidayRequestAction.CMD_EDIT_MODE);
			}
		} else if (actionName.equals(WorkOnHolidayRequestAction.class.getName())) {
			if (getTransferredActivateDate() == null) {
				// 振出・休出申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(WorkOnHolidayRequestAction.CMD_SELECT_SHOW);
			} else {
				// 振出・休出申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(WorkOnHolidayRequestAction.CMD_EDIT_MODE);
			}
		} else if (actionName.equals(SubHolidayRequestAction.class.getName())) {
			if (getTransferredActivateDate() == null || getTransferredType() == null) {
				// 代休申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(SubHolidayRequestAction.CMD_SELECT_SHOW);
			} else {
				// 代休申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(SubHolidayRequestAction.CMD_EDIT_MODE);
			}
		} else if (actionName.equals(DifferenceRequestAction.class.getName())) {
			if (getTransferredActivateDate() == null) {
				// 時差出勤申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(DifferenceRequestAction.CMD_SELECT_SHOW);
			} else {
				// 時差出勤申請画面へ遷移(連続実行コマンド設定)
				mospParams.setNextCommand(DifferenceRequestAction.CMD_EDIT_MODE);
			}
		}
	}
	
	/**
	 * 勤怠詳細情報を取得し、VOに設定する。
	 * 対象個人ID及び対象日で、人事情報、勤怠情報、承認者情報を取得し設定する。<br>
	 * @param personalId 対象個人ID
	 * @param targetDate 対象日
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setAttendaneCardInfo(String personalId, Date targetDate) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 人事情報をVOに設定
		setEmployeeInfo(personalId, targetDate);
		// 各領域の初期化
		setDefaultValues();
		// 申請状況を設定する
		setApplicationStatus();
		// 退職済確認
		if (reference().retirement().isRetired(personalId, targetDate)) {
			addEmployeeRetiredMessage();
		}
		// 休職期間確認
		if (reference().suspension().isSuspended(personalId, targetDate)) {
			addEmployeeSuspendedMessage();
		}
		// 処理結果確認
		if (mospParams.hasErrorMessage()) {
			// 申請モード設定
			vo.setModeCardEdit(MODE_APPLICATION_COMPLETED_HOLIDAY);
			return;
		}
		// 申請ユーティリティクラス準備
		RequestUtilBeanInterface requestUtil = timeReference().requestUtil();
		// 各種申請情報取得
		requestUtil.setRequests(personalId, targetDate);
		// 出退勤情報
		attendanceInfo();
		// リクエストされた値を設定する
		setTransferredValues();
		// 勤務形態、勤務形態プルダウン、申請モードを設定
		setWorkType(requestUtil);
		// 出退勤修正データ
		attendanceCorrectInfo();
		// 休憩情報設定
		setRest(requestUtil);
		// 外出情報設定
		setGoOut();
		// 遅刻早退情報
		tardinessLeaveearlyInfo();
		// 割増情報
		premiumInfo();
		// 手当情報
		allowanceInfo();
		// 勤怠情報承認状況
		attendanceInfoApprovalStatus();
		// 承認者用プルダウン設定
		setApprvalPullDown(personalId, targetDate);
	}
	
	/**
	 * 勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * @param requestUtil 申請ユーティリティ
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setWorkType(RequestUtilBeanInterface requestUtil) throws MospException {
		// 勤怠情報取得(取下、下書、1次戻以外)
		AttendanceDtoInterface attendanceDto = requestUtil.getApplicatedAttendance();
		// 時差出勤申請取得(承認済)
		DifferenceRequestDtoInterface differenceRequestDto = requestUtil.getDifferenceDto(true);
		// 申請された勤怠情報が存在する場合
		if (attendanceDto != null) {
			// 申請済勤怠申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定
			setWorkTypeForApplicatedAttendance(attendanceDto, differenceRequestDto != null);
			// 処理終了
			return;
		}
		// 休暇申請取得(承認済、全休)及び確認
		HolidayRequestDtoInterface holidayRequestDto = requestUtil.getCompletedHolidayRangeAll();
		if (holidayRequestDto != null) {
			// 承認済休暇申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定
			setWorkTypeForHolidayRequest(holidayRequestDto);
			// 処理終了
			return;
		}
		// 代休申請取得(承認済、全休)及び確認
		SubHolidayRequestDtoInterface subHolidayRequestDto = requestUtil.getCompletedSubHolidayRangeAll();
		if (subHolidayRequestDto != null) {
			// 承認済代休申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定
			setWorkTypeForSubHolidayRequest(subHolidayRequestDto);
			// 処理終了
			return;
		}
		// 振替休日取得(承認済、全休)及び確認
		SubstituteDtoInterface subsutituteDto = requestUtil.getCompletedSubstituteRangeAll();
		if (subsutituteDto != null) {
			// 承認済振替休日情報に対して、勤務形態、勤務形態プルダウン、申請モードを設定
			setWorkTypeForSubstitute(subsutituteDto, requestUtil);
			// 処理終了
			return;
		}
		// 全休(半休 + 半休)確認
		if (requestUtil.isHolidayAllDay(true)) {
			// 承認済全休(半休 + 半休)に対して、勤務形態、勤務形態プルダウン、申請モードを設定
			setWorkTypeForHolidayAllDay();
			// 処理終了
			return;
		}
		// 時差出勤申請確認(承認済)
		if (differenceRequestDto != null) {
			// 承認済時差出勤申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定
			setWorkTypeForDifferenceRequest(differenceRequestDto, requestUtil);
			// 処理終了
			return;
		}
		// 振出休出申請確認
		if (setWorkTypeForWorkOnHolidayRequest(requestUtil)) {
			// 処理終了
			return;
		}
		// カレンダに対して、勤務形態、勤務形態プルダウン、申請モードを設定
		setWorkTypeForSchedule(requestUtil);
	}
	
	/**
	 * 申請済勤怠申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * @param attendanceDto 勤怠申請情報
	 * @param isDifference 時差出勤の場合true、そうでない場合false
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setWorkTypeForApplicatedAttendance(AttendanceDtoInterface attendanceDto, boolean isDifference)
			throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤務形態参照クラス準備
		WorkTypeReferenceBeanInterface workTypeRefer = timeReference().workType();
		// 勤務形態取得
		String workTypeCode = attendanceDto.getWorkTypeCode();
		// 特殊な勤務形態の名称を取得
		String workTypeName = workTypeRefer.getParticularWorkTypeName(workTypeCode);
		// 特殊な勤務形態でない場合
		if (workTypeName == null) {
			// 勤務形態プルダウン用配列取得(勤務形態略称【出勤時刻～退勤時刻】)
			String[][] aryWorkType = workTypeRefer.getTimeSelectArray(vo.getTargetDate());
			// 勤務形態プルダウン用配列から名称を取得
			workTypeName = MospUtility.getCodeName(workTypeCode, aryWorkType);
		}
		// 勤務形態及び勤務形態プルダウン用配列を設定
		setPltWorkType(workTypeCode, workTypeName);
		// 時差出勤の場合
		if (isDifference) {
			// 時差出勤区分取得
			String differenceType = workTypeCode;
			// 勤務形態設定(時差出勤区分)
			vo.setPltWorkType(differenceType);
			// 勤務形態プルダウン設定(時差出勤のプルダウン)
			vo.setAryPltWorkType(timeReference().differenceRequest().getDifferenceSelectArray(differenceType));
		}
		// 申請モード設定(申請済)
		vo.setModeCardEdit(TimeConst.MODE_APPLICATION_APPLIED);
	}
	
	/**
	 * 承認済休暇申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * @param holidayRequestDto 休暇申請情報
	 */
	protected void setWorkTypeForHolidayRequest(HolidayRequestDtoInterface holidayRequestDto) {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤務形態及び勤務形態プルダウン用配列を設定(休暇種別確認)
		switch (holidayRequestDto.getHolidayType1()) {
			// 有給休暇の場合
			case TimeConst.CODE_HOLIDAYTYPE_HOLIDAY:
				setPltWorkType(mospParams.getName("PaidVacation"));
				break;
			// 特別休暇の場合
			case TimeConst.CODE_HOLIDAYTYPE_SPECIAL:
				setPltWorkType(mospParams.getName("Specially") + mospParams.getName("Vacation"));
				break;
			// その他休暇の場合
			case TimeConst.CODE_HOLIDAYTYPE_OTHER:
				setPltWorkType(mospParams.getName("Others") + mospParams.getName("Vacation"));
				break;
			// 欠勤の場合
			case TimeConst.CODE_HOLIDAYTYPE_ABSENCE:
				setPltWorkType(mospParams.getName("Absence"));
				break;
			default:
				setPltWorkType("");
		}
		// 申請モード設定(休日承認済)
		vo.setModeCardEdit(MODE_APPLICATION_COMPLETED_HOLIDAY);
	}
	
	/**
	 * 承認済代休申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * @param subHolidayRequestDto 代休申請情報
	 */
	protected void setWorkTypeForSubHolidayRequest(SubHolidayRequestDtoInterface subHolidayRequestDto) {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤務形態及び勤務形態プルダウン用配列を設定(代休種別確認)
		switch (subHolidayRequestDto.getWorkDateSubHolidayType()) {
			// 所定代休の場合
			case TimeConst.CODE_PRESCRIBED_SUBHOLIDAY_CODE:
				setPltWorkType(mospParams.getName("Prescribed") + mospParams.getName("Generation")
						+ mospParams.getName("Rest"));
				break;
			// 法定代休の場合
			case TimeConst.CODE_LEGAL_SUBHOLIDAY_CODE:
				setPltWorkType(mospParams.getName("Legal") + mospParams.getName("Generation")
						+ mospParams.getName("Rest"));
				break;
			// 深夜代休の場合
			case TimeConst.CODE_MIDNIGHT_SUBHOLIDAY_CODE:
				setPltWorkType(mospParams.getName("Midnight") + mospParams.getName("Generation")
						+ mospParams.getName("Rest"));
				break;
			default:
				setPltWorkType("");
		}
		// 申請モード設定(休日承認済)
		vo.setModeCardEdit(MODE_APPLICATION_COMPLETED_HOLIDAY);
	}
	
	/**
	 * 承認済全休(半休 + 半休)に対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 */
	protected void setWorkTypeForHolidayAllDay() {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤務形態及び勤務形態プルダウン用配列を設定
		setPltWorkType(mospParams.getName("Application") + mospParams.getName("In") + mospParams.getName("From")
				+ mospParams.getName("Vacation") + mospParams.getName("Finish"));
		// 申請モード設定(休日承認済)
		vo.setModeCardEdit(MODE_APPLICATION_COMPLETED_HOLIDAY);
	}
	
	/**
	 * 振出休出申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * 勤怠申請(下書或いは1次戻)が存在する場合、勤務形態、申請モードを設定(上書)する。
	 * @param requestUtil 申請ユーティリティ
	 * @return 結果可否
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected boolean setWorkTypeForWorkOnHolidayRequest(RequestUtilBeanInterface requestUtil) throws MospException {
		// 振出休出申請取得(承認済、休日出勤)及び確認
		WorkOnHolidayRequestDtoInterface workOnHolidayRequestDto = requestUtil.getWorkOnHolidayDto(true);
		if (workOnHolidayRequestDto == null) {
			return false;
		}
		// 承認済振出休出申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定
		setWorkTypeForWorkOnHolidayRequest(workOnHolidayRequestDto, requestUtil);
		return true;
	}
	
	/**
	 * 振出休出申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * 勤怠申請(下書或いは1次戻)が存在する場合、勤務形態、申請モードを設定(上書)する。
	 * @param workOnHolidayRequestDto 振出休出情報
	 * @param requestUtil             申請ユーティリティ
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setWorkTypeForWorkOnHolidayRequest(WorkOnHolidayRequestDtoInterface workOnHolidayRequestDto,
			RequestUtilBeanInterface requestUtil) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		ApplicationReferenceBeanInterface application = timeReference().application();
		ScheduleReferenceBeanInterface schedule = timeReference().schedule();
		// 振替申請区分取得
		int substitute = workOnHolidayRequestDto.getSubstitute();
		// 振替申請区分確認(休日出勤の場合)
		if (substitute == TimeConst.CODE_WORK_ON_HOLIDAY_SUBSTITUTE_OFF) {
			// 勤務形態準備
			String workTypeCode = "";
			// 休出種別取得
			String workOnHolidayType = workOnHolidayRequestDto.getWorkOnHolidayType();
			// 法定休日の場合
			if (TimeConst.CODE_HOLIDAY_LEGAL_HOLIDAY.equals(workOnHolidayType)) {
				workTypeCode = TimeConst.CODE_WORK_ON_LEGAL_HOLIDAY;
			}
			// 所定休日の場合
			if (TimeConst.CODE_HOLIDAY_PRESCRIBED_HOLIDAY.equals(workOnHolidayType)) {
				workTypeCode = TimeConst.CODE_WORK_ON_PRESCRIBED_HOLIDAY;
			}
			// 勤務形態及び勤務形態プルダウン用配列を設定
			setPltWorkType(workTypeCode, timeReference().workType().getParticularWorkTypeName(workTypeCode));
			// 申請モード設定(新規)
			vo.setModeCardEdit(TimeConst.MODE_APPLICATION_NEW);
			// 勤怠申請(下書或いは1次戻)が存在する場合、勤務形態、申請モードを設定(上書)
			setWorkTypeForNotApplicatedAttendance(requestUtil);
		}
		// 振替申請区分確認(振替出勤の場合)
		if (substitute == TimeConst.CODE_WORK_ON_HOLIDAY_SUBSTITUTE_ON) {
			// 個人ID取得
			String personalId = vo.getPersonalId();
			// 対象日(休日出勤の日)を取得
			Date targetDate = vo.getTargetDate();
			ApplicationDtoInterface applicationDto = application.findForPerson(personalId, targetDate);
			application.chkExistApplication(applicationDto, targetDate);
			if (mospParams.hasErrorMessage()) {
				return;
			}
			ScheduleDtoInterface scheduleDto = schedule.getScheduleInfo(applicationDto.getScheduleCode(), targetDate);
			schedule.chkExistSchedule(scheduleDto, targetDate);
			if (mospParams.hasErrorMessage()) {
				return;
			}
			// 対象日で勤務形態プルダウン用配列を取得(勤務形態略称【出勤時刻～退勤時刻】)
			String[][] aryWorkType = getWorkTypeArray(scheduleDto.getPatternCode());
			// 振替休日の日を取得
			Date substituteDate = timeReference().substitute().getSubstituteDate(workOnHolidayRequestDto.getWorkflow());
			// カレンダの勤務形態コード(振替休日の日)を取得
			String workTypeCode = timeReference().ScheduleUtil().getScheduledWorkTypeCode(personalId, substituteDate);
			if (mospParams.hasErrorMessage()) {
				// 申請モード設定
				vo.setModeCardEdit(MODE_APPLICATION_COMPLETED_HOLIDAY);
				return;
			}
			int workTypeChangeFlag = scheduleDto.getWorkTypeChangeFlag();
			if (workTypeChangeFlag == MospConst.DELETE_FLAG_OFF) {
				// 勤務形態変更可の場合
				// VOに勤務形態コードを設定
				vo.setPltWorkType(workTypeCode);
				// 勤務形態プルダウン設定(勤務形態略称【出勤時刻～退勤時刻】)
				vo.setAryPltWorkType(aryWorkType);
			} else if (workTypeChangeFlag == MospConst.DELETE_FLAG_ON) {
				// 勤務形態変更不可の場合
				setPltWorkType(workTypeCode, MospUtility.getCodeName(workTypeCode, aryWorkType));
			}
			// 申請モード設定(新規)
			vo.setModeCardEdit(TimeConst.MODE_APPLICATION_NEW);
			// 勤怠申請(下書或いは1次戻)が存在する場合、勤務形態、申請モードを設定(上書)
			setWorkTypeForNotApplicatedAttendance(requestUtil);
		}
	}
	
	/**
	 * 承認済振替休日情報に対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * 振替の振替があった場合には、
	 * 承認済振出休出申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * @param subsutituteDto 振替休日情報
	 * @param requestUtil    申請ユーティリティ
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setWorkTypeForSubstitute(SubstituteDtoInterface subsutituteDto, RequestUtilBeanInterface requestUtil)
			throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 振替種別取得
		String substituteType = subsutituteDto.getSubstituteType();
		// 所定振替休日の場合
		if (substituteType.equals(TimeConst.CODE_HOLIDAY_PRESCRIBED_HOLIDAY)) {
			setPltWorkType(mospParams.getName("Prescribed") + mospParams.getName("Transfer")
					+ mospParams.getName("Holiday"));
		}
		// 法定振替休日の場合
		if (substituteType.equals(TimeConst.CODE_HOLIDAY_LEGAL_HOLIDAY)) {
			setPltWorkType(mospParams.getName("Legal") + mospParams.getName("Transfer") + mospParams.getName("Holiday"));
		}
		// 申請モード設定(休日承認済)
		vo.setModeCardEdit(MODE_APPLICATION_COMPLETED_HOLIDAY);
		// 振替の振替を確認
		setWorkTypeForWorkOnHolidayRequest(requestUtil);
	}
	
	/**
	 * 承認済時差出勤申請に対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * 勤怠申請(下書或いは1次戻)が存在する場合、勤務形態、申請モードを設定(上書)する。
	 * @param differenceRequestDto 時差出勤申請情報
	 * @param requestUtil          申請ユーティリティ
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setWorkTypeForDifferenceRequest(DifferenceRequestDtoInterface differenceRequestDto,
			RequestUtilBeanInterface requestUtil) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 時差出勤区分取得
		String differenceType = differenceRequestDto.getDifferenceType();
		// 勤務形態設定(時差出勤区分)
		vo.setPltWorkType(differenceType);
		// 勤務形態プルダウン設定(時差出勤のプルダウン)
		vo.setAryPltWorkType(timeReference().differenceRequest().getDifferenceSelectArray(differenceType));
		// 申請モード設定(新規)
		vo.setModeCardEdit(TimeConst.MODE_APPLICATION_NEW);
		// 勤怠申請(下書或いは1次戻)が存在する場合、勤務形態、申請モードを設定(上書)
		setWorkTypeForNotApplicatedAttendance(requestUtil);
	}
	
	/**
	 * カレンダに対して、勤務形態、勤務形態プルダウン、申請モードを設定する。<br>
	 * 勤怠申請(下書或いは1次戻)が存在する場合、勤務形態、申請モードを設定(上書)する。
	 * @param requestUtil 申請ユーティリティ
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setWorkTypeForSchedule(RequestUtilBeanInterface requestUtil) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		ApplicationReferenceBeanInterface application = timeReference().application();
		ScheduleReferenceBeanInterface schedule = timeReference().schedule();
		// 個人ID及び対象日を取得
		String personalId = vo.getPersonalId();
		Date targetDate = vo.getTargetDate();
		// カレンダの勤務形態コードを取得
		String workTypeCode = timeReference().ScheduleUtil().getScheduledWorkTypeCode(personalId, targetDate);
		if (mospParams.hasErrorMessage()) {
			// 申請モード設定
			vo.setModeCardEdit(MODE_APPLICATION_COMPLETED_HOLIDAY);
		}
		// カレンダの勤務形態コードを確認(法定休日或いは所定休日の場合)
		if (TimeConst.CODE_HOLIDAY_PRESCRIBED_HOLIDAY.equals(workTypeCode)
				|| TimeConst.CODE_HOLIDAY_LEGAL_HOLIDAY.equals(workTypeCode)) {
			// 勤務形態及び勤務形態プルダウン用配列を設定
			setPltWorkType(workTypeCode, timeReference().workType().getParticularWorkTypeName(workTypeCode));
			// 申請モード設定(休日承認済)
			vo.setModeCardEdit(MODE_APPLICATION_COMPLETED_HOLIDAY);
		} else {
			ApplicationDtoInterface applicationDto = application.findForPerson(personalId, targetDate);
			application.chkExistApplication(applicationDto, targetDate);
			if (mospParams.hasErrorMessage()) {
				return;
			}
			ScheduleDtoInterface scheduleDto = schedule.getScheduleInfo(applicationDto.getScheduleCode(), targetDate);
			schedule.chkExistSchedule(scheduleDto, targetDate);
			if (mospParams.hasErrorMessage()) {
				return;
			}
			// 勤務形態プルダウン用配列取得(勤務形態略称【出勤時刻～退勤時刻】)
			String[][] aryWorkType = getWorkTypeArray(scheduleDto.getPatternCode());
			int workTypeChangeFlag = scheduleDto.getWorkTypeChangeFlag();
			if (workTypeChangeFlag == MospConst.DELETE_FLAG_OFF) {
				// 勤務形態変更可の場合
				// VOに勤務形態コードを設定
				vo.setPltWorkType(workTypeCode);
				// 勤務形態プルダウン設定(勤務形態略称【出勤時刻～退勤時刻】)
				vo.setAryPltWorkType(aryWorkType);
			} else if (workTypeChangeFlag == MospConst.DELETE_FLAG_ON) {
				// 勤務形態変更不可の場合
				setPltWorkType(workTypeCode, MospUtility.getCodeName(workTypeCode, aryWorkType));
			}
			// 申請モード設定(新規)
			vo.setModeCardEdit(TimeConst.MODE_APPLICATION_NEW);
		}
		// 勤怠申請(下書或いは1次戻)が存在する場合、勤務形態、申請モードを設定(上書)
		setWorkTypeForNotApplicatedAttendance(requestUtil);
	}
	
	/**
	 * 勤怠申請情報(下書或いは1次戻)に対して、勤務形態、申請モードを設定する。<br>
	 * @param requestUtil 申請ユーティリティ
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setWorkTypeForNotApplicatedAttendance(RequestUtilBeanInterface requestUtil) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤怠申請情報(下書)取得
		AttendanceDtoInterface attendanceDto = requestUtil.getDraftAttendance();
		// 下書の勤怠申請が存在する場合
		if (attendanceDto != null) {
			// 勤務形態をVOに設定
			vo.setPltWorkType(attendanceDto.getWorkTypeCode());
			// 申請モード設定(下書編集)
			vo.setModeCardEdit(TimeConst.MODE_APPLICATION_DRAFT);
		}
		// 勤怠申請情報(1次戻)取得
		attendanceDto = requestUtil.getFirstRevertedAttendance();
		// 1次戻の勤怠申請が存在する場合
		if (attendanceDto != null) {
			// 勤務形態をVOに設定
			vo.setPltWorkType(attendanceDto.getWorkTypeCode());
			// 申請モード設定(差戻編集)
			vo.setModeCardEdit(TimeConst.MODE_APPLICATION_REVERT);
		}
		// 対象個人IDにつき対象日付が未締であるかを確認(未締でない場合)
		if (timeReference().cutoffUtil().isNotTighten(vo.getPersonalId(), vo.getTargetDate()) == false) {
			// 申請モード設定(申請済)
			vo.setModeCardEdit(TimeConst.MODE_APPLICATION_APPLIED);
		}
	}
	
	/**
	 * 勤怠情報をVOに設定する。
	 * @throws MospException 例外発生時
	 */
	protected void attendanceInfo() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		Date localTargetDate = vo.getTargetDate();
		// 勤怠情報取得
		AttendanceDtoInterface dto = timeReference().attendance().findForKey(vo.getPersonalId(), localTargetDate, 1);
		// 勤怠情報確認
		if (dto == null) {
			return;
		}
		// 勤怠情報設定(勤務形態コードは別途設定)
		vo.setTxtStartTimeHour(DateUtility.getStringHour(dto.getStartTime()));
		vo.setTxtStartTimeMinute(DateUtility.getStringMinute(dto.getStartTime()));
		vo.setTxtEndTimeHour(DateUtility.getStringHour(dto.getEndTime(), dto.getWorkDate()));
		vo.setTxtEndTimeMinute(DateUtility.getStringMinute(dto.getEndTime()));
		vo.setLblWorkTime(getTimeTimeFormat(dto.getWorkTime()));
		vo.setLblGeneralWorkTime(getTimeTimeFormat(dto.getGeneralWorkTime()));
		vo.setCkbDirectStart(String.valueOf(dto.getDirectStart()));
		vo.setCkbDirectEnd(String.valueOf(dto.getDirectEnd()));
		vo.setTxtTimeComment(dto.getTimeComment());
		vo.setTmdAttendanceId(String.valueOf(dto.getTmdAttendanceId()));
		vo.setPltLateReason(dto.getLateReason());
		vo.setPltLateCertificate(String.valueOf(dto.getLateCertificate()));
		vo.setTxtLateComment(dto.getLateComment());
		vo.setPltLeaveEarlyReason(dto.getLeaveEarlyReason());
		vo.setPltLeaveEarlyCertificate(String.valueOf(dto.getLeaveEarlyCertificate()));
		vo.setTxtLeaveEarlyComment(dto.getLeaveEarlyComment());
		vo.setLblLateTime(getTimeTimeFormat(dto.getLateTime()));
		vo.setLblLeaveEarlyTime(getTimeTimeFormat(dto.getLeaveEarlyTime()));
		vo.setLblOvertime(getTimeTimeFormat(dto.getOvertime()));
		vo.setLblOvertimeIn(getTimeTimeFormat(dto.getOvertimeIn()));
		vo.setLblOvertimeOut(getTimeTimeFormat(dto.getOvertimeOut()));
		vo.setLblLateNightTime(getTimeTimeFormat(dto.getLateNightTime()));
		vo.setLblSpecificWorkTimeIn(getTimeTimeFormat(dto.getSpecificWorkTime()));
		vo.setLblLegalWorkTime(getTimeTimeFormat(dto.getLegalWorkTime()));
		vo.setLblDecreaseTime(getTimeTimeFormat(dto.getDecreaseTime()));
	}
	
	/**
	 * 出退勤修正データ
	 * @throws MospException 例外発生時
	 */
	protected void attendanceCorrectInfo() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// DTO準備
		AttendanceCorrectionDtoInterface dto = timeReference().attendanceCorrection()
			.getLatestAttendanceCorrectionInfo(vo.getPersonalId(), vo.getTargetDate(), TimeBean.TIMES_WORK_DEFAULT);
		if (dto == null) {
			return;
		}
		// 修正理由
		vo.setTxtCorrectionReason(dto.getCorrectionReason());
		// 修正情報
		StringBuffer sb = new StringBuffer();
		sb.append(mospParams.getName("Corrector"));
		sb.append(mospParams.getName("Colon"));
		sb.append(reference().human().getHumanName(dto.getCorrectionPersonalId(), dto.getCorrectionDate()));
		sb.append(" ");
		sb.append(mospParams.getName("Day"));
		sb.append(mospParams.getName("Hour"));
		sb.append(mospParams.getName("Colon"));
		sb.append(DateUtility.getStringDateAndDayAndTime(dto.getCorrectionDate()));
		vo.setLblCorrectionHistory(sb.toString());
	}
	
	/**
	 * 休憩情報を設定する。<br>
	 * 勤怠情報が無い場合は、カレンダに登録されている勤務形態の休憩時間を設定する。<br>
	 * @param requestUtil 申請ユーティリティ
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setRest(RequestUtilBeanInterface requestUtil) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// DTO準備
		AttendanceDtoInterface dto = timeReference().attendance().findForKey(vo.getPersonalId(), vo.getTargetDate(),
				TimeBean.TIMES_WORK_DEFAULT);
		// 勤怠情報が無い場合
		if (dto == null) {
			// カレンダに登録されている勤務形態の休憩時間を設定
			setScheduledRest(requestUtil);
			return;
		}
		vo.setLblRestTime(getTimeTimeFormat(dto.getRestTime()));
		vo.setLblOverRestTime(getTimeTimeFormat(dto.getOverRestTime()));
		vo.setLblNightRestTime(getTimeTimeFormat(dto.getNightRestTime()));
		if (dto.getStartTime() == null || dto.getEndTime() == null) {
			// 始業時刻又は終業時刻がない場合
			long standardTime = DateUtility.getDateTime(DateUtility.getYear(vo.getTargetDate()),
					DateUtility.getMonth(vo.getTargetDate()), DateUtility.getDay(vo.getTargetDate()), 0, 0).getTime();
			List<RestDtoInterface> list = timeReference().rest().getRestList(vo.getPersonalId(), vo.getTargetDate(), 1);
			for (RestDtoInterface restDto : list) {
				if (restDto.getRestStart().getTime() != standardTime || restDto.getRestEnd().getTime() != standardTime) {
					// 登録されている休憩時間をセット
					setRegisteredRest();
					return;
				}
			}
			// カレンダに登録されている勤務形態の休憩時間を設定
			setScheduledRest(requestUtil);
			return;
		}
		// 登録されている休憩時間をセット
		setRegisteredRest();
	}
	
	/**
	 * カレンダに登録されている休憩情報を設定する。<br>
	 * 但し、設定されている申請モードが休日承認済の場合は、休憩情報を設定しない。<br>
	 * 承認済の振出休出申請が存在する場合は、
	 * 振替申請区分が振替出勤の場合は振替休日の勤務形態に依り、
	 * それ以外の場合は休憩情報を設定しない。<br>
	 * 承認済の時差出勤申請が存在する場合は、時差出勤区分に依る。<br>
	 * @param requestUtil 申請ユーティリティ
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	protected void setScheduledRest(RequestUtilBeanInterface requestUtil) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 対象個人ID及び対象日付準備
		String personalId = vo.getPersonalId();
		Date targetDate = vo.getTargetDate();
		// カレンダに登録されている勤務形態コードを取得するための日付
		Date scheduleDate = vo.getTargetDate();
		// 申請モード確認(休日承認済の場合)
		if (vo.getModeCardEdit().equals(MODE_APPLICATION_COMPLETED_HOLIDAY)) {
			// 処理無し(休日承認済の場合)
			return;
		}
		// 振出休出申請情報取得(承認済)及び確認
		WorkOnHolidayRequestDtoInterface workOnHolidayRequestDto = requestUtil.getWorkOnHolidayDto(true);
		if (workOnHolidayRequestDto != null) {
			// 振替申請区分確認
			if (workOnHolidayRequestDto.getSubstitute() == TimeConst.CODE_WORK_ON_HOLIDAY_SUBSTITUTE_ON) {
				// カレンダに登録されている勤務形態コードを取得するための日付を再設定(振替出勤の場合)
				scheduleDate = timeReference().substitute().getSubstituteDate(workOnHolidayRequestDto.getWorkflow());
			} else {
				// 処理無し(振替出勤でない場合)
				return;
			}
		}
		// 休暇申請情報取得(承認済)及び確認
		if (!requestUtil.getHolidayList(true).isEmpty()) {
			// 処理無し(休暇承認済の場合)
			return;
		}
		// 代休申請情報取得(承認済)及び確認
		if (!requestUtil.getSubHolidayList(true).isEmpty()) {
			// 処理無し(代休承認済の場合)
			return;
		}
		// 時差出勤申請情報取得(承認済)及び確認
		DifferenceRequestDtoInterface differenceRequestDto = requestUtil.getDifferenceDto(true);
		if (differenceRequestDto != null) {
			if (TimeConst.CODE_DIFFERENCE_TYPE_A.equals(differenceRequestDto.getDifferenceType())
					|| TimeConst.CODE_DIFFERENCE_TYPE_B.equals(differenceRequestDto.getDifferenceType())
					|| TimeConst.CODE_DIFFERENCE_TYPE_C.equals(differenceRequestDto.getDifferenceType())
					|| TimeConst.CODE_DIFFERENCE_TYPE_D.equals(differenceRequestDto.getDifferenceType())) {
				// 時差出勤区分A・B・C・D
				Date startTime = DateUtility.getTime(12, 0);
				Date endTime = DateUtility.getTime(13, 0);
				vo.setTxtRestStartHour1(DateUtility.getStringHour(startTime));
				vo.setTxtRestStartMinute1(DateUtility.getStringMinute(startTime));
				vo.setTxtRestEndHour1(DateUtility.getStringHour(endTime));
				vo.setTxtRestEndMinute1(DateUtility.getStringMinute(endTime));
				return;
			} else if (TimeConst.CODE_DIFFERENCE_TYPE_S.equals(differenceRequestDto.getDifferenceType())) {
				// 時差出勤区分S
				Date startTime = DateUtility.addHour(differenceRequestDto.getRequestStart(), 3);
				Date endTime = DateUtility.addHour(differenceRequestDto.getRequestStart(), 4);
				vo.setTxtRestStartHour1(DateUtility.getStringHour(startTime, vo.getTargetDate()));
				vo.setTxtRestStartMinute1(DateUtility.getStringMinute(startTime));
				vo.setTxtRestEndHour1(DateUtility.getStringHour(endTime, vo.getTargetDate()));
				vo.setTxtRestEndMinute1(DateUtility.getStringMinute(endTime));
				return;
			}
		}
		// カレンダに登録されている勤務形態コードを取得
		String workTypeCode = timeReference().ScheduleUtil().getScheduledWorkTypeCode(personalId, scheduleDate);
		if (mospParams.hasErrorMessage()) {
			return;
		}
		Date defaultDate = DateUtility.getDate(MospConst.DEFAULT_YEAR, Calendar.JANUARY + 1, 1);
		// 休憩1
		WorkTypeItemDtoInterface restStart1Dto = timeReference().workTypeItem().getWorkTypeItemInfo(workTypeCode,
				targetDate, TimeConst.CODE_RESTSTART1);
		WorkTypeItemDtoInterface restEnd1Dto = timeReference().workTypeItem().getWorkTypeItemInfo(workTypeCode,
				targetDate, TimeConst.CODE_RESTEND1);
		if (restStart1Dto != null && restEnd1Dto != null) {
			vo.setTxtRestStartHour1(DateUtility.getStringHour(restStart1Dto.getWorkTypeItemValue(), defaultDate));
			vo.setTxtRestStartMinute1(DateUtility.getStringMinute(restStart1Dto.getWorkTypeItemValue()));
			vo.setTxtRestEndHour1(DateUtility.getStringHour(restEnd1Dto.getWorkTypeItemValue(), defaultDate));
			vo.setTxtRestEndMinute1(DateUtility.getStringMinute(restEnd1Dto.getWorkTypeItemValue()));
		}
		// 休憩2
		WorkTypeItemDtoInterface restStart2Dto = timeReference().workTypeItem().getWorkTypeItemInfo(workTypeCode,
				targetDate, TimeConst.CODE_RESTSTART2);
		WorkTypeItemDtoInterface restEnd2Dto = timeReference().workTypeItem().getWorkTypeItemInfo(workTypeCode,
				targetDate, TimeConst.CODE_RESTEND2);
		if (restStart2Dto != null && restEnd2Dto != null) {
			vo.setTxtRestStartHour2(DateUtility.getStringHour(restStart2Dto.getWorkTypeItemValue(), defaultDate));
			vo.setTxtRestStartMinute2(DateUtility.getStringMinute(restStart2Dto.getWorkTypeItemValue()));
			vo.setTxtRestEndHour2(DateUtility.getStringHour(restEnd2Dto.getWorkTypeItemValue(), defaultDate));
			vo.setTxtRestEndMinute2(DateUtility.getStringMinute(restEnd2Dto.getWorkTypeItemValue()));
		}
		// 休憩3
		WorkTypeItemDtoInterface restStart3Dto = timeReference().workTypeItem().getWorkTypeItemInfo(workTypeCode,
				targetDate, TimeConst.CODE_RESTSTART3);
		WorkTypeItemDtoInterface restEnd3Dto = timeReference().workTypeItem().getWorkTypeItemInfo(workTypeCode,
				targetDate, TimeConst.CODE_RESTEND3);
		if (restStart3Dto != null && restEnd3Dto != null) {
			vo.setTxtRestStartHour3(DateUtility.getStringHour(restStart3Dto.getWorkTypeItemValue(), defaultDate));
			vo.setTxtRestStartMinute3(DateUtility.getStringMinute(restStart3Dto.getWorkTypeItemValue()));
			vo.setTxtRestEndHour3(DateUtility.getStringHour(restEnd3Dto.getWorkTypeItemValue(), defaultDate));
			vo.setTxtRestEndMinute3(DateUtility.getStringMinute(restEnd3Dto.getWorkTypeItemValue()));
		}
		// 休憩4
		WorkTypeItemDtoInterface restStart4Dto = timeReference().workTypeItem().getWorkTypeItemInfo(workTypeCode,
				targetDate, TimeConst.CODE_RESTSTART4);
		WorkTypeItemDtoInterface restEnd4Dto = timeReference().workTypeItem().getWorkTypeItemInfo(workTypeCode,
				targetDate, TimeConst.CODE_RESTEND4);
		if (restStart4Dto != null && restEnd4Dto != null) {
			vo.setTxtRestStartHour4(DateUtility.getStringHour(restStart4Dto.getWorkTypeItemValue(), defaultDate));
			vo.setTxtRestStartMinute4(DateUtility.getStringMinute(restStart4Dto.getWorkTypeItemValue()));
			vo.setTxtRestEndHour4(DateUtility.getStringHour(restEnd4Dto.getWorkTypeItemValue(), defaultDate));
			vo.setTxtRestEndMinute4(DateUtility.getStringMinute(restEnd4Dto.getWorkTypeItemValue()));
		}
	}
	
	/**
	 * 登録されている休憩情報を設定する。<br>
	 * @throws MospException 例外発生時
	 */
	protected void setRegisteredRest() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤怠データ休憩情報リスト取得
		List<RestDtoInterface> list = timeReference().rest().getRestList(vo.getPersonalId(), vo.getTargetDate(), 1);
		for (RestDtoInterface dto : list) {
			if (dto.getRest() == 1) {
				vo.setTxtRestStartHour1(DateUtility.getStringHour(dto.getRestStart(), vo.getTargetDate()));
				vo.setTxtRestStartMinute1(DateUtility.getStringMinute(dto.getRestStart()));
				vo.setTxtRestEndHour1(DateUtility.getStringHour(dto.getRestEnd(), vo.getTargetDate()));
				vo.setTxtRestEndMinute1(DateUtility.getStringMinute(dto.getRestEnd()));
			}
			if (dto.getRest() == 2) {
				vo.setTxtRestStartHour2(DateUtility.getStringHour(dto.getRestStart(), vo.getTargetDate()));
				vo.setTxtRestStartMinute2(DateUtility.getStringMinute(dto.getRestStart()));
				vo.setTxtRestEndHour2(DateUtility.getStringHour(dto.getRestEnd(), vo.getTargetDate()));
				vo.setTxtRestEndMinute2(DateUtility.getStringMinute(dto.getRestEnd()));
			}
			if (dto.getRest() == 3) {
				vo.setTxtRestStartHour3(DateUtility.getStringHour(dto.getRestStart(), vo.getTargetDate()));
				vo.setTxtRestStartMinute3(DateUtility.getStringMinute(dto.getRestStart()));
				vo.setTxtRestEndHour3(DateUtility.getStringHour(dto.getRestEnd(), vo.getTargetDate()));
				vo.setTxtRestEndMinute3(DateUtility.getStringMinute(dto.getRestEnd()));
			}
			if (dto.getRest() == 4) {
				vo.setTxtRestStartHour4(DateUtility.getStringHour(dto.getRestStart(), vo.getTargetDate()));
				vo.setTxtRestStartMinute4(DateUtility.getStringMinute(dto.getRestStart()));
				vo.setTxtRestEndHour4(DateUtility.getStringHour(dto.getRestEnd(), vo.getTargetDate()));
				vo.setTxtRestEndMinute4(DateUtility.getStringMinute(dto.getRestEnd()));
			}
			if (dto.getRest() == 5) {
				vo.setTxtRestStartHour5(DateUtility.getStringHour(dto.getRestStart(), vo.getTargetDate()));
				vo.setTxtRestStartMinute5(DateUtility.getStringMinute(dto.getRestStart()));
				vo.setTxtRestEndHour5(DateUtility.getStringHour(dto.getRestEnd(), vo.getTargetDate()));
				vo.setTxtRestEndMinute5(DateUtility.getStringMinute(dto.getRestEnd()));
			}
			if (dto.getRest() == 6) {
				vo.setTxtRestStartHour6(DateUtility.getStringHour(dto.getRestStart(), vo.getTargetDate()));
				vo.setTxtRestStartMinute6(DateUtility.getStringMinute(dto.getRestStart()));
				vo.setTxtRestEndHour6(DateUtility.getStringHour(dto.getRestEnd(), vo.getTargetDate()));
				vo.setTxtRestEndMinute6(DateUtility.getStringMinute(dto.getRestEnd()));
			}
		}
	}
	
	/**
	 * 外出情報を設定する。<br>
	 * @throws MospException 例外発生時
	 */
	protected void setGoOut() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// DTO準備
		AttendanceDtoInterface attendanceDto = timeReference().attendance().findForKey(vo.getPersonalId(),
				vo.getTargetDate(), 1);
		if (attendanceDto == null) {
			return;
		}
		vo.setLblPublicTime(getTimeTimeFormat(attendanceDto.getPublicTime()));
		vo.setLblPrivateTime(getTimeTimeFormat(attendanceDto.getPrivateTime()));
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				GoOutDtoInterface goOutDto = timeReference().goOut().findForKey(vo.getPersonalId(), vo.getTargetDate(),
						1, i + 1, j + 1);
				// データが存在しない場合
				if (goOutDto == null) {
					continue;
				}
				// 公用外出
				if (goOutDto.getGoOutType() == TimeConst.CODE_GO_OUT_PUBLIC) {
					if (goOutDto.getTimesGoOut() == TimeConst.CODE_GO_OUT_PUBLIC) {
						// 外出開始時刻。
						vo.setTxtPublicStartHour1(DateUtility.getStringHour(goOutDto.getGoOutStart(), attendanceDto
							.getWorkDate()));
						vo.setTxtPublicStartMinute1(DateUtility.getStringMinute(goOutDto.getGoOutStart()));
						// 外出終了時刻。
						vo.setTxtPublicEndHour1(DateUtility.getStringHour(goOutDto.getGoOutEnd(), attendanceDto
							.getWorkDate()));
						vo.setTxtPublicEndMinute1(DateUtility.getStringMinute(goOutDto.getGoOutEnd()));
					}
					if (goOutDto.getTimesGoOut() == TimeConst.CODE_GO_OUT_PRIVATE) {
						// 外出開始時刻。
						vo.setTxtPublicStartHour2(DateUtility.getStringHour(goOutDto.getGoOutStart(), attendanceDto
							.getWorkDate()));
						vo.setTxtPublicStartMinute2(DateUtility.getStringMinute(goOutDto.getGoOutStart()));
						// 外出終了時刻。
						vo.setTxtPublicEndHour2(DateUtility.getStringHour(goOutDto.getGoOutEnd(), attendanceDto
							.getWorkDate()));
						vo.setTxtPublicEndMinute2(DateUtility.getStringMinute(goOutDto.getGoOutEnd()));
					}
				}
				// 私用外出
				if (goOutDto.getGoOutType() == TimeConst.CODE_GO_OUT_PRIVATE) {
					if (goOutDto.getTimesGoOut() == TimeConst.CODE_GO_OUT_PUBLIC) {
						// 外出開始時刻。
						vo.setTxtPrivateStartHour1(DateUtility.getStringHour(goOutDto.getGoOutStart(), attendanceDto
							.getWorkDate()));
						vo.setTxtPrivateStartMinute1(DateUtility.getStringMinute(goOutDto.getGoOutStart()));
						// 外出終了時刻。
						vo.setTxtPrivateEndHour1(DateUtility.getStringHour(goOutDto.getGoOutEnd(), attendanceDto
							.getWorkDate()));
						vo.setTxtPrivateEndMinute1(DateUtility.getStringMinute(goOutDto.getGoOutEnd()));
					}
					if (goOutDto.getTimesGoOut() == TimeConst.CODE_GO_OUT_PRIVATE) {
						// 外出開始時刻。
						vo.setTxtPrivateStartHour2(DateUtility.getStringHour(goOutDto.getGoOutStart(), attendanceDto
							.getWorkDate()));
						vo.setTxtPrivateStartMinute2(DateUtility.getStringMinute(goOutDto.getGoOutStart()));
						// 外出終了時刻。
						vo.setTxtPrivateEndHour2(DateUtility.getStringHour(goOutDto.getGoOutEnd(), attendanceDto
							.getWorkDate()));
						vo.setTxtPrivateEndMinute2(DateUtility.getStringMinute(goOutDto.getGoOutEnd()));
					}
				}
			}
		}
	}
	
	/**
	 * 遅刻早退情報
	 * @throws MospException 例外発生時
	 */
	protected void tardinessLeaveearlyInfo() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// DTO準備
		AttendanceDtoInterface dto = timeReference().attendance().findForKey(vo.getLblEmployeeCode(),
				vo.getTargetDate(), 1);
		// 遅刻早退情報
		if (dto != null) {
			vo.setLblLateTime(getTimeTimeFormat(dto.getLateTime()));
			vo.setPltLateReason(dto.getLateReason());
			vo.setPltLateCertificate(String.valueOf(dto.getLateCertificate()));
			vo.setTxtLateComment(dto.getLateComment());
			vo.setLblLeaveEarlyTime(getTimeTimeFormat(dto.getLeaveEarlyTime()));
			vo.setPltLeaveEarlyReason(dto.getLeaveEarlyReason());
			vo.setPltLeaveEarlyCertificate(String.valueOf(dto.getLeaveEarlyCertificate()));
			vo.setTxtLeaveEarlyComment(dto.getLeaveEarlyComment());
		}
	}
	
	/**
	 * 割増情報
	 * @throws MospException 例外発生時
	 */
	protected void premiumInfo() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// DTO準備
		AttendanceDtoInterface dto = timeReference().attendance().findForKey(vo.getLblEmployeeCode(),
				vo.getTargetDate(), 1);
		// 割増情報
		if (dto != null) {
			vo.setLblOvertime(getTimeTimeFormat(dto.getOvertime()));
			vo.setLblOvertimeIn(getTimeTimeFormat(dto.getOvertimeIn()));
			vo.setLblOvertimeOut(getTimeTimeFormat(dto.getOvertimeOut()));
			vo.setLblLateNightTime(getTimeTimeFormat(dto.getLateNightTime()));
			vo.setLblSpecificWorkTimeIn(getTimeTimeFormat(dto.getSpecificWorkTime()));
			vo.setLblSpecificWorkTimeOver("");
			vo.setLblLegalWorkTime(getTimeTimeFormat(dto.getLegalWorkTime()));
			vo.setLblDecreaseTime(getTimeTimeFormat(dto.getDecreaseTime()));
		}
	}
	
	/**
	 * 手当情報
	 * @throws MospException 例外発生時
	 */
	protected void allowanceInfo() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 手当情報
		// 勤務回数は固定で「1」
		AllowanceDtoInterface dto = null;
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INFO1);
		if (dto != null) {
			vo.setPltAllowance1(String.valueOf(dto.getAllowance()));
		}
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INFO2);
		if (dto != null) {
			vo.setPltAllowance2(String.valueOf(dto.getAllowance()));
		}
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INFO3);
		if (dto != null) {
			vo.setPltAllowance3(String.valueOf(dto.getAllowance()));
		}
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INFO4);
		if (dto != null) {
			vo.setPltAllowance4(String.valueOf(dto.getAllowance()));
		}
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INFO5);
		if (dto != null) {
			vo.setPltAllowance5(String.valueOf(dto.getAllowance()));
		}
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INFO6);
		if (dto != null) {
			vo.setPltAllowance6(String.valueOf(dto.getAllowance()));
		}
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INFO7);
		if (dto != null) {
			vo.setPltAllowance7(String.valueOf(dto.getAllowance()));
		}
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INFO8);
		if (dto != null) {
			vo.setPltAllowance8(String.valueOf(dto.getAllowance()));
		}
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INFO9);
		if (dto != null) {
			vo.setPltAllowance9(String.valueOf(dto.getAllowance()));
		}
		dto = timeReference().allowance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1,
				TimeConst.CODE_ALLOWANCE_CODE_INF10);
		if (dto != null) {
			vo.setPltAllowance10(String.valueOf(dto.getAllowance()));
		}
	}
	
	/**
	 * ワークフロー関連情報を設定する。<br>
	 * 承認状況・ワークフローコメント・申請モードを設定する。<br>
	 * @throws MospException ワークフロー情報の取得に失敗した場合
	 */
	protected void attendanceInfoApprovalStatus() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤怠情報取得及び確認
		AttendanceDtoInterface dto = timeReference().attendance().findForKey(vo.getPersonalId(), vo.getTargetDate(), 1);
		if (dto == null) {
			return;
		}
		// ワークフロー情報取得
		WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(dto.getWorkflow());
		WorkflowCommentDtoInterface commentDto = reference().workflowComment().getLatestWorkflowCommentInfo(
				dto.getWorkflow());
		// ワークフロー情報確認
		if (workflowDto == null) {
			return;
		}
		// 勤怠情報承認状況設定
		vo.setLblAttendanceState(getStatusStageValueView(workflowDto.getWorkflowStatus(), workflowDto
			.getWorkflowStage()));
		// ワークフローコメント情報設定
		if (commentDto != null) {
			vo.setLblAttendanceComment(getWorkflowCommentDtoComment(workflowDto, commentDto));
			vo.setLblAttendanceApprover(getWorkflowCommentDtoLastFirstName(workflowDto, commentDto));
		}
	}
	
	/**
	 * 残業申請状況
	 * @throws MospException 例外発生時
	 */
	protected void overtimeApplicationStatus() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		StringBuffer transferParams = new StringBuffer();
		transferParams.append("'");
		transferParams.append(PlatformConst.PRM_TRANSFERRED_ACTION);
		transferParams.append("', '");
		transferParams.append(OvertimeRequestAction.class.getName());
		transferParams.append("'");
		vo.setLblOvertimeTransferParams(transferParams.toString());
		vo.setLblOvertimeCmd(CMD_TRANSFER);
		// DTO準備
		AttendanceDtoInterface attendanceDto = timeReference().attendance().findForKey(vo.getPersonalId(),
				vo.getTargetDate(), 1);
		List<OvertimeRequestDtoInterface> list = timeReference().overtimeRequest().getOvertimeRequestList(
				vo.getPersonalId(), vo.getTargetDate(), vo.getTargetDate());
		List<OvertimeRequestDtoInterface> overRequestList = new ArrayList<OvertimeRequestDtoInterface>();
		for (OvertimeRequestDtoInterface dto : list) {
			// ワークフロー情報の取得
			WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(dto.getWorkflow());
			if (workflowDto == null) {
				continue;
			}
			if (PlatformConst.CODE_STATUS_WITHDRAWN.equals(workflowDto.getWorkflowStatus())) {
				// 取下の場合
				continue;
			}
			overRequestList.add(dto);
		}
		int size = overRequestList.size();
		String[] aryLblOvertimeType = new String[size];
		String[] aryLblOvertimeSchedule = new String[size];
		String[] aryLblOvertimeResult = new String[size];
		String[] aryLblOvertimeReason = new String[size];
		String[] aryLblOvertimeState = new String[size];
		String[] aryLblOvertimeComment = new String[size];
		String[] aryLblOvertimeApprover = new String[size];
		for (int i = 0; i < overRequestList.size(); i++) {
			OvertimeRequestDtoInterface dto = overRequestList.get(i);
			long workflow = dto.getWorkflow();
			// ワークフロー情報の取得
			WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(workflow);
			WorkflowCommentDtoInterface commentDto = reference().workflowComment().getLatestWorkflowCommentInfo(
					workflow);
			int overtimeType = dto.getOvertimeType();
			aryLblOvertimeType[i] = getOvertimeTypeName(overtimeType);
			aryLblOvertimeSchedule[i] = getTimeTimeFormat(dto.getRequestTime());
			aryLblOvertimeResult[i] = mospParams.getName("Hyphen");
			if (attendanceDto != null) {
				int result = 0;
				if (overtimeType == TimeConst.CODE_OVERTIME_WORK_BEFORE) {
					// 勤務前残業
					result = attendanceDto.getOvertimeBefore();
				} else if (overtimeType == TimeConst.CODE_OVERTIME_WORK_AFTER) {
					// 勤務後残業
					result = attendanceDto.getOvertimeAfter();
				}
				aryLblOvertimeResult[i] = getTimeTimeFormat(result);
			}
			aryLblOvertimeReason[i] = dto.getRequestReason();
			aryLblOvertimeState[i] = getStatusStageValueView(workflowDto.getWorkflowStatus(), workflowDto
				.getWorkflowStage());
			aryLblOvertimeComment[i] = getWorkflowCommentDtoComment(workflowDto, commentDto);
			aryLblOvertimeApprover[i] = getWorkflowCommentDtoLastFirstName(workflowDto, commentDto);
			if (i == 0
					&& (PlatformConst.CODE_STATUS_DRAFT.equals(workflowDto.getWorkflowStatus()) || PlatformConst.CODE_STATUS_REVERT
						.equals(workflowDto.getWorkflowStatus()))) {
				// 下書又は差戻の場合
				StringBuffer params = new StringBuffer();
				params.append("'");
				params.append(PlatformConst.PRM_TRANSFERRED_ACTION);
				params.append("', '");
				params.append(OvertimeRequestAction.class.getName());
				params.append("', '");
				params.append(PlatformConst.PRM_TRANSFERRED_ACTIVATE_DATE);
				params.append("', '");
				params.append(DateUtility.getStringDate(dto.getRequestDate()));
				params.append("', '");
				params.append(TimeConst.PRM_TRANSFERRED_TYPE);
				params.append("', '");
				params.append(dto.getOvertimeType());
				params.append("'");
				vo.setLblOvertimeTransferParams(params.toString());
				vo.setLblOvertimeCmd(CMD_TRANSFER);
			}
		}
		// VOに項目を設定
		vo.setLblOvertimeType(aryLblOvertimeType);
		vo.setLblOvertimeSchedule(aryLblOvertimeSchedule);
		vo.setLblOvertimeResult(aryLblOvertimeResult);
		vo.setLblOvertimeReason(aryLblOvertimeReason);
		vo.setLblOvertimeState(aryLblOvertimeState);
		vo.setLblOvertimeComment(aryLblOvertimeComment);
		vo.setLblOvertimeApprover(aryLblOvertimeApprover);
	}
	
	/**
	 * 休暇申請状況
	 * @throws MospException 例外発生時
	 */
	protected void vacationApplicationStatus() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		StringBuffer transferParams = new StringBuffer();
		transferParams.append("'");
		transferParams.append(PlatformConst.PRM_TRANSFERRED_ACTION);
		transferParams.append("', '");
		transferParams.append(HolidayRequestAction.class.getName());
		transferParams.append("'");
		vo.setLblHolidayTransferParams(transferParams.toString());
		vo.setLblHolidayCmd(CMD_TRANSFER);
		String workTypeCode = getBeforeDifferenceRequestWorkTypeCode();
		if (TimeConst.CODE_HOLIDAY_LEGAL_HOLIDAY.equals(workTypeCode)
				|| TimeConst.CODE_HOLIDAY_PRESCRIBED_HOLIDAY.equals(workTypeCode)) {
			// 法定休日又は所定休日の場合
			return;
		}
		// DTO準備
		List<HolidayRequestDtoInterface> list = timeReference().holidayRequest().getHolidayRequestList(
				vo.getPersonalId(), vo.getTargetDate());
		List<HolidayRequestDtoInterface> holidayRequestList = new ArrayList<HolidayRequestDtoInterface>();
		for (HolidayRequestDtoInterface dto : list) {
			// ワークフロー情報の取得
			WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(dto.getWorkflow());
			// ワークフロー情報がないか取下の場合
			if (workflowDto == null || PlatformConst.CODE_STATUS_WITHDRAWN.equals(workflowDto.getWorkflowStatus())) {
				continue;
			}
			holidayRequestList.add(dto);
		}
		int size = holidayRequestList.size();
		String[] aryLblHolidayType = new String[size];
		String[] aryLblHolidayLength = new String[size];
		String[] aryLblHolidayTime = new String[size];
		String[] aryLblHolidayReason = new String[size];
		String[] aryLblHolidayState = new String[size];
		String[] aryLblHolidayApprover = new String[size];
		String[] aryLblHolidayComment = new String[size];
		for (int i = 0; i < holidayRequestList.size(); i++) {
			HolidayRequestDtoInterface dto = holidayRequestList.get(i);
			long workflow = dto.getWorkflow();
			// ワークフロー情報の取得
			WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(workflow);
			WorkflowCommentDtoInterface commentDto = reference().workflowComment().getLatestWorkflowCommentInfo(
					workflow);
			aryLblHolidayType[i] = getHolidayTypeName(dto.getHolidayType1(), dto.getHolidayType2(), dto
				.getRequestStartDate());
			aryLblHolidayLength[i] = getHolidayRange(dto.getHolidayRange());
			aryLblHolidayTime[i] = getTimeWaveFormat(dto.getStartTime(), dto.getEndTime());
			aryLblHolidayReason[i] = dto.getRequestReason();
			aryLblHolidayState[i] = getStatusStageValueView(workflowDto.getWorkflowStatus(), workflowDto
				.getWorkflowStage());
			aryLblHolidayApprover[i] = getWorkflowCommentDtoLastFirstName(workflowDto, commentDto);
			aryLblHolidayComment[i] = getWorkflowCommentDtoComment(workflowDto, commentDto);
			if (i == 0
					&& (PlatformConst.CODE_STATUS_DRAFT.equals(workflowDto.getWorkflowStatus()) || PlatformConst.CODE_STATUS_REVERT
						.equals(workflowDto.getWorkflowStatus()))) {
				// 下書又は差戻の場合
				StringBuffer params = new StringBuffer();
				params.append("'");
				params.append(PlatformConst.PRM_TRANSFERRED_ACTION);
				params.append("', '");
				params.append(HolidayRequestAction.class.getName());
				params.append("', '");
				params.append(PlatformConst.PRM_TRANSFERRED_ACTIVATE_DATE);
				params.append("', '");
				params.append(DateUtility.getStringDate(dto.getRequestStartDate()));
				params.append("', '");
				params.append(TimeConst.PRM_TRANSFERRED_HOLIDAY_TYPE1);
				params.append("', '");
				params.append(dto.getHolidayType1());
				params.append("', '");
				params.append(TimeConst.PRM_TRANSFERRED_HOLIDAY_TYPE2);
				params.append("', '");
				params.append(dto.getHolidayType2());
				params.append("', '");
				params.append(TimeConst.PRM_TRANSFERRED_HOLIDAY_RANGE);
				params.append("', '");
				params.append(dto.getHolidayRange());
				params.append("', '");
				params.append(TimeConst.PRM_TRANSFERRED_START_TIME);
				params.append("', '");
				params.append(DateUtility.getStringTime(dto.getStartTime()));
				params.append("'");
				vo.setLblHolidayTransferParams(params.toString());
				vo.setLblHolidayCmd(CMD_TRANSFER);
			}
		}
		// VOに項目を設定
		vo.setLblHolidayType(aryLblHolidayType);
		vo.setLblHolidayLength(aryLblHolidayLength);
		vo.setLblHolidayTime(aryLblHolidayTime);
		vo.setLblHolidayReason(aryLblHolidayReason);
		vo.setLblHolidayState(aryLblHolidayState);
		vo.setLblHolidayComment(aryLblHolidayComment);
		vo.setLblHolidayApprover(aryLblHolidayApprover);
	}
	
	/**
	 * 休日出勤申請状況
	 * @throws MospException 例外発生時
	 */
	protected void holidayWorkApplicationStatus() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		StringBuffer transferParams = new StringBuffer();
		transferParams.append("'");
		transferParams.append(PlatformConst.PRM_TRANSFERRED_ACTION);
		transferParams.append("', '");
		transferParams.append(WorkOnHolidayRequestAction.class.getName());
		transferParams.append("'");
		vo.setLblWorkOnHolidayTransferParams(transferParams.toString());
		vo.setLblWorkOnHolidayCmd(CMD_TRANSFER);
		// 休日出勤申請からレコードを取得
		WorkOnHolidayRequestDtoInterface dto = timeReference().workOnHolidayRequest().findForKeyOnWorkflow(
				vo.getPersonalId(), vo.getTargetDate());
		if (dto == null) {
			return;
		}
		long workflow = dto.getWorkflow();
		// ワークフロー情報の取得
		WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(workflow);
		if (workflowDto == null) {
			return;
		}
		if (PlatformConst.CODE_STATUS_WITHDRAWN.equals(workflowDto.getWorkflowStatus())) {
			// 取下の場合
			return;
		}
		// 最新のワークフローコメント取得
		WorkflowCommentDtoInterface commentDto = reference().workflowComment().getLatestWorkflowCommentInfo(
				dto.getWorkflow());
		// 振替休日情報の取得
		List<SubstituteDtoInterface> list = timeReference().substitute().getSubstituteList(workflow);
		// 休日出勤申請状況
		vo.setLblWorkOnHolidayDate(DateUtility.getStringDateAndDay(dto.getRequestDate()));
		vo.setLblWorkOnHolidayTime(getTimeWaveFormat(dto.getStartTime(), dto.getEndTime(), dto.getRequestDate()));
		vo.setLblSubStituteDate("");
		for (SubstituteDtoInterface substituteDto : list) {
			vo.setLblSubStituteDate(DateUtility.getStringDateAndDay(substituteDto.getSubstituteDate()));
			break;
		}
		vo.setLblWorkOnHolidayReason(dto.getRequestReason());
		// 状態
		vo.setLblWorkOnHolidayState(getStatusStageValueView(workflowDto.getWorkflowStatus(), workflowDto
			.getWorkflowStage()));
		vo.setLblWorkOnHolidayComment(getWorkflowCommentDtoComment(workflowDto, commentDto));
		vo.setLblWorkOnHolidayApprover(getWorkflowCommentDtoLastFirstName(workflowDto, commentDto));
		if (PlatformConst.CODE_STATUS_DRAFT.equals(workflowDto.getWorkflowStatus())
				|| PlatformConst.CODE_STATUS_REVERT.equals(workflowDto.getWorkflowStatus())) {
			// 下書又は差戻の場合
			StringBuffer params = new StringBuffer();
			params.append("'");
			params.append(PlatformConst.PRM_TRANSFERRED_ACTION);
			params.append("', '");
			params.append(WorkOnHolidayRequestAction.class.getName());
			params.append("', '");
			params.append(PlatformConst.PRM_TRANSFERRED_ACTIVATE_DATE);
			params.append("', '");
			params.append(DateUtility.getStringDate(dto.getRequestDate()));
			params.append("'");
			vo.setLblWorkOnHolidayTransferParams(params.toString());
			vo.setLblWorkOnHolidayCmd(CMD_TRANSFER);
		}
	}
	
	/**
	 * 代休申請状況
	 * @throws MospException 例外発生時
	 */
	protected void compensatoryleaveApplicationStatus() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		StringBuffer transferParams = new StringBuffer();
		transferParams.append("'");
		transferParams.append(PlatformConst.PRM_TRANSFERRED_ACTION);
		transferParams.append("', '");
		transferParams.append(SubHolidayRequestAction.class.getName());
		transferParams.append("'");
		vo.setLblSubHolidayTransferParams(transferParams.toString());
		vo.setLblSubHolidayCmd(CMD_TRANSFER);
		// DTO準備
		// 年月日は締め日
		List<SubHolidayRequestDtoInterface> list = timeReference().subHolidayRequest().getSubHolidayRequestList(
				vo.getPersonalId(), vo.getTargetDate());
		List<SubHolidayRequestDtoInterface> subHolidayRequestList = new ArrayList<SubHolidayRequestDtoInterface>();
		for (SubHolidayRequestDtoInterface dto : list) {
			// ワークフロー情報の取得
			WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(dto.getWorkflow());
			if (workflowDto == null) {
				continue;
			}
			if (PlatformConst.CODE_STATUS_WITHDRAWN.equals(workflowDto.getWorkflowStatus())) {
				// 取下の場合
				continue;
			}
			subHolidayRequestList.add(dto);
		}
		int size = subHolidayRequestList.size();
		String[] aryLblSubHolidayDate = new String[size];
		String[] aryLblSubHolidayWorkDate = new String[size];
		String[] aryLblSubHolidayState = new String[size];
		String[] aryLblSubHolidayComment = new String[size];
		String[] aryLblSubHolidayApprover = new String[size];
		for (int i = 0; i < subHolidayRequestList.size(); i++) {
			SubHolidayRequestDtoInterface dto = subHolidayRequestList.get(i);
			long workflow = dto.getWorkflow();
			// ワークフロー情報の取得
			WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(workflow);
			WorkflowCommentDtoInterface commentDto = reference().workflowComment().getLatestWorkflowCommentInfo(
					workflow);
			aryLblSubHolidayDate[i] = DateUtility.getStringDateAndDay(dto.getRequestDate());
			aryLblSubHolidayWorkDate[i] = DateUtility.getStringDateAndDay(dto.getWorkDate());
			aryLblSubHolidayState[i] = getStatusStageValueView(workflowDto.getWorkflowStatus(), workflowDto
				.getWorkflowStage());
			aryLblSubHolidayComment[i] = getWorkflowCommentDtoComment(workflowDto, commentDto);
			aryLblSubHolidayApprover[i] = getWorkflowCommentDtoLastFirstName(workflowDto, commentDto);
			if (i == 0
					&& (PlatformConst.CODE_STATUS_DRAFT.equals(workflowDto.getWorkflowStatus()) || PlatformConst.CODE_STATUS_REVERT
						.equals(workflowDto.getWorkflowStatus()))) {
				// 下書又は差戻の場合
				StringBuffer params = new StringBuffer();
				params.append("'");
				params.append(PlatformConst.PRM_TRANSFERRED_ACTION);
				params.append("', '");
				params.append(SubHolidayRequestAction.class.getName());
				params.append("', '");
				params.append(PlatformConst.PRM_TRANSFERRED_ACTIVATE_DATE);
				params.append("', '");
				params.append(DateUtility.getStringDate(dto.getRequestDate()));
				params.append("', '");
				params.append(TimeConst.PRM_TRANSFERRED_TYPE);
				params.append("', '");
				params.append(dto.getHolidayRange());
				params.append("'");
				vo.setLblSubHolidayTransferParams(params.toString());
				vo.setLblSubHolidayCmd(CMD_TRANSFER);
			}
		}
		// VOに項目を設定
		vo.setLblSubHolidayDate(aryLblSubHolidayDate);
		vo.setLblSubHolidayWorkDate(aryLblSubHolidayWorkDate);
		vo.setLblSubHolidayState(aryLblSubHolidayState);
		vo.setLblSubHolidayComment(aryLblSubHolidayComment);
		vo.setLblSubHolidayApprover(aryLblSubHolidayApprover);
	}
	
	/**
	 * 時差出勤申請状況
	 * @throws MospException 例外発生時
	 */
	protected void timedifferenceWorkApplicationStatus() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		StringBuffer transferParams = new StringBuffer();
		transferParams.append("'");
		transferParams.append(PlatformConst.PRM_TRANSFERRED_ACTION);
		transferParams.append("', '");
		transferParams.append(DifferenceRequestAction.class.getName());
		transferParams.append("'");
		vo.setLblDifferenceTransferParams(transferParams.toString());
		vo.setLblDifferenceCmd(CMD_TRANSFER);
		// DTO準備
		// 年月日は締め日
		DifferenceRequestDtoInterface dto = timeReference().differenceRequest().findForKeyOnWorkflow(
				vo.getPersonalId(), vo.getTargetDate());
		if (dto == null) {
			return;
		}
		long workflow = dto.getWorkflow();
		// ワークフロー情報の取得
		WorkflowDtoInterface workflowDto = reference().workflow().getLatestWorkflowInfo(workflow);
		if (workflowDto == null) {
			return;
		}
		if (PlatformConst.CODE_STATUS_WITHDRAWN.equals(workflowDto.getWorkflowStatus())) {
			// 取下の場合
			return;
		}
		WorkflowCommentDtoInterface commentDto = reference().workflowComment().getLatestWorkflowCommentInfo(workflow);
		// 時差出勤申請状況
		vo.setLblDifferenceDate(DateUtility.getStringDateAndDay(dto.getRequestDate()));
		vo.setLblDifferenceWorkType(getBeforeDifferenceRequestWorkTypeAbbr());
		vo.setLblDifferenceWorkTime(timeReference().differenceRequest().getDifferenceTime(dto));
		vo.setLblDifferenceReason(dto.getRequestReason());
		// 状態
		vo.setLblDifferenceState(getStatusStageValueView(workflowDto.getWorkflowStatus(), workflowDto
			.getWorkflowStage()));
		vo.setLblDifferenceComment(getWorkflowCommentDtoComment(workflowDto, commentDto));
		vo.setLblDifferenceApprover(getWorkflowCommentDtoLastFirstName(workflowDto, commentDto));
		if (PlatformConst.CODE_STATUS_DRAFT.equals(workflowDto.getWorkflowStatus())
				|| PlatformConst.CODE_STATUS_REVERT.equals(workflowDto.getWorkflowStatus())) {
			// 下書又は差戻の場合
			StringBuffer params = new StringBuffer();
			params.append("'");
			params.append(PlatformConst.PRM_TRANSFERRED_ACTION);
			params.append("', '");
			params.append(DifferenceRequestAction.class.getName());
			params.append("', '");
			params.append(PlatformConst.PRM_TRANSFERRED_ACTIVATE_DATE);
			params.append("', '");
			params.append(DateUtility.getStringDate(dto.getRequestDate()));
			params.append("'");
			vo.setLblDifferenceTransferParams(params.toString());
			vo.setLblDifferenceCmd(CMD_TRANSFER);
		}
	}
	
	/**
	 * 勤怠詳細画面の初期値を設定する。<br>
	 */
	protected void setDefaultValues() {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		vo.setModeCardEdit(TimeConst.MODE_APPLICATION_APPLIED);
		vo.setLblYear(String.valueOf(DateUtility.getYear(vo.getTargetDate())));
		vo.setLblMonth(String.valueOf(DateUtility.getMonth(vo.getTargetDate())));
		vo.setLblDay(String.valueOf(DateUtility.getDay(vo.getTargetDate())));
		vo.setCkbDirectStart("0");
		vo.setCkbDirectEnd("0");
		vo.setTmdAttendanceId("0");
		vo.setTxtCorrectionReason("");
		vo.setLblCorrectionHistory("");
		vo.setTxtStartTimeHour("");
		vo.setTxtStartTimeMinute("");
		vo.setTxtEndTimeHour("");
		vo.setTxtEndTimeMinute("");
		vo.setLblWorkTime("");
		vo.setLblRestTime("");
		vo.setLblOverRestTime("");
		vo.setLblNightRestTime("");
		vo.setLblPublicTime("");
		vo.setLblPrivateTime("");
		vo.setTxtRestStartHour1("");
		vo.setTxtRestStartMinute1("");
		vo.setTxtRestEndHour1("");
		vo.setTxtRestEndMinute1("");
		vo.setTxtRestStartHour2("");
		vo.setTxtRestStartMinute2("");
		vo.setTxtRestEndHour2("");
		vo.setTxtRestEndMinute2("");
		vo.setTxtRestStartHour3("");
		vo.setTxtRestStartMinute3("");
		vo.setTxtRestEndHour3("");
		vo.setTxtRestEndMinute3("");
		vo.setTxtRestStartHour4("");
		vo.setTxtRestStartMinute4("");
		vo.setTxtRestEndHour4("");
		vo.setTxtRestEndMinute4("");
		vo.setTxtRestStartHour5("");
		vo.setTxtRestStartMinute5("");
		vo.setTxtRestEndHour5("");
		vo.setTxtRestEndMinute5("");
		vo.setTxtRestStartHour6("");
		vo.setTxtRestStartMinute6("");
		vo.setTxtRestEndHour6("");
		vo.setTxtRestEndMinute6("");
		vo.setTxtPublicStartHour1("");
		vo.setTxtPublicStartMinute1("");
		vo.setTxtPublicEndHour1("");
		vo.setTxtPublicEndMinute1("");
		vo.setTxtPublicStartHour2("");
		vo.setTxtPublicStartMinute2("");
		vo.setTxtPublicEndHour2("");
		vo.setTxtPublicEndMinute2("");
		vo.setTxtPrivateStartHour1("");
		vo.setTxtPrivateStartMinute1("");
		vo.setTxtPrivateEndHour1("");
		vo.setTxtPrivateEndMinute1("");
		vo.setTxtPrivateStartHour2("");
		vo.setTxtPrivateStartMinute2("");
		vo.setTxtPrivateEndHour2("");
		vo.setTxtPrivateEndMinute2("");
		vo.setLblLateTime("");
		vo.setPltLateReason("");
		vo.setPltLateCertificate("");
		vo.setTxtLateComment("");
		vo.setLblLeaveEarlyTime("");
		vo.setPltLeaveEarlyReason("");
		vo.setPltLeaveEarlyCertificate("");
		vo.setTxtLeaveEarlyComment("");
		vo.setLblOvertime("");
		vo.setLblOvertimeIn("");
		vo.setLblOvertimeOut("");
		vo.setLblLateNightTime("");
		vo.setLblSpecificWorkTimeIn("");
		vo.setLblSpecificWorkTimeOver("");
		vo.setLblLegalWorkTime("");
		vo.setLblDecreaseTime("");
		vo.setLblAttendanceComment("");
		vo.setLblAttendanceState("");
		vo.setLblAttendanceApprover("");
		vo.setLblOvertimeType(new String[0]);
		vo.setLblOvertimeSchedule(new String[0]);
		vo.setLblOvertimeResult(new String[0]);
		vo.setLblOvertimeReason(new String[0]);
		vo.setLblOvertimeState(new String[0]);
		vo.setLblOvertimeComment(new String[0]);
		vo.setLblOvertimeApprover(new String[0]);
		vo.setLblHolidayType(new String[0]);
		vo.setLblHolidayLength(new String[0]);
		vo.setLblHolidayTime(new String[0]);
		vo.setLblHolidayReason(new String[0]);
		vo.setLblHolidayState(new String[0]);
		vo.setLblHolidayComment(new String[0]);
		vo.setLblHolidayApprover(new String[0]);
		vo.setLblWorkOnHolidayDate("");
		vo.setLblWorkOnHolidayTime("");
		vo.setLblSubStituteDate("");
		vo.setLblWorkOnHolidayReason("");
		vo.setLblWorkOnHolidayState("");
		vo.setLblWorkOnHolidayComment("");
		vo.setLblWorkOnHolidayApprover("");
		vo.setLblSubHolidayDate(new String[0]);
		vo.setLblSubHolidayWorkDate(new String[0]);
		vo.setLblSubHolidayState(new String[0]);
		vo.setLblSubHolidayComment(new String[0]);
		vo.setLblSubHolidayApprover(new String[0]);
		vo.setLblDifferenceDate("");
		vo.setLblDifferenceWorkType("");
		vo.setLblDifferenceWorkTime("");
		vo.setLblDifferenceReason("");
		vo.setLblDifferenceState("");
		vo.setLblDifferenceComment("");
		vo.setLblDifferenceApprover("");
		vo.setLblGeneralWorkTime("");
		vo.setTxtTimeComment("");
		vo.setPltAllowance1("0");
		vo.setPltAllowance2("0");
		vo.setPltAllowance3("0");
		vo.setPltAllowance4("0");
		vo.setPltAllowance5("0");
		vo.setPltAllowance6("0");
		vo.setPltAllowance7("0");
		vo.setPltAllowance8("0");
		vo.setPltAllowance9("0");
		vo.setPltAllowance10("0");
		vo.setPltWorkType("");
		// 申請モードの初期化
		vo.setModeCardEdit("");
		// 承認者欄の初期化
		vo.setAryPltLblApproverSetting(new String[0]);
		vo.setPltApproverSetting1("");
		vo.setPltApproverSetting2("");
		vo.setPltApproverSetting3("");
		vo.setPltApproverSetting4("");
		vo.setPltApproverSetting5("");
		vo.setPltApproverSetting6("");
		vo.setPltApproverSetting7("");
		vo.setPltApproverSetting8("");
		vo.setPltApproverSetting9("");
		vo.setPltApproverSetting10("");
	}
	
	/**
	 * 申請状況を設定する。<br>
	 * @throws MospException 例外発生時
	 */
	protected void setApplicationStatus() throws MospException {
		// 残業申請状況
		overtimeApplicationStatus();
		// 休暇申請状況
		vacationApplicationStatus();
		// 休日出勤申請状況
		holidayWorkApplicationStatus();
		// 代休申請状況
		compensatoryleaveApplicationStatus();
		// 時差出勤申請状況
		timedifferenceWorkApplicationStatus();
	}
	
	/**
	 * リクエストされた値を設定する。<br>
	 */
	protected void setTransferredValues() {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		if (getTransferredStartHour() != null) {
			// 始業時刻
			vo.setTxtStartTimeHour(getTransferredStartHour());
			vo.setTxtStartTimeMinute(getTransferredStartMinute());
		}
		if (getTransferredEndHour() != null) {
			// 終業時刻
			vo.setTxtEndTimeHour(getTransferredEndHour());
			vo.setTxtEndTimeMinute(getTransferredEndMinute());
		}
		if (getTransferredDirectStart() != null) {
			// 直行
			vo.setCkbDirectStart(getTransferredDirectStart());
		}
		if (getTransferredDirectEnd() != null) {
			// 直帰
			vo.setCkbDirectEnd(getTransferredDirectEnd());
		}
		if (getTransferredTimeComment() != null) {
			// 勤怠コメント
			vo.setTxtTimeComment(getTransferredTimeComment());
		}
	}
	
	/**
	 * プルダウン設定
	 * @throws MospException 例外発生時
	 */
	protected void setPulldown() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// プルダウン設定(勤務形態プルダウンは別途設定
		vo.setAryPltAllowance(mospParams.getProperties().getCodeArray(TimeConst.CODE_ALLOWANCE, false));
		vo.setAryPltLateReason(mospParams.getProperties().getCodeArray(TimeConst.CODE_REASON_OF_LATE, true));
		vo.setAryPltLeaveEarlyReason(mospParams.getProperties()
			.getCodeArray(TimeConst.CODE_REASON_OF_LEAVE_EARLY, true));
		vo.setAryPltLateCertificate(mospParams.getProperties().getCodeArray(TimeConst.CODE_ALLOWANCE, true));
	}
	
	/**
	 * VO(編集項目)の値をDTOに設定する。<br>
	 * @param dto 対象DTO
	 * @throws MospException 例外発生時
	 */
	protected void setAttendanceDtoFields(AttendanceDtoInterface dto) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// レコード識別ID
		dto.setTmdAttendanceId(Long.valueOf(vo.getTmdAttendanceId()));
		// 出退勤情報
		dto.setPersonalId(vo.getPersonalId());
		// 勤務形態
		dto.setWorkTypeCode(vo.getPltWorkType());
		// 勤務日
		dto.setWorkDate(vo.getTargetDate());
		// 勤務回数
		dto.setTimesWork(TimeBean.TIMES_WORK_DEFAULT);
		// 出勤時刻
		dto.setStartTime(getAttendanceTime(vo.getTxtStartTimeHour(), vo.getTxtStartTimeMinute()));
		// 退勤時刻
		dto.setEndTime(getAttendanceTime(vo.getTxtEndTimeHour(), vo.getTxtEndTimeMinute()));
		// 直行
		dto.setDirectStart(Integer.parseInt(vo.getCkbDirectStart()));
		// 直帰
		dto.setDirectEnd(Integer.parseInt(vo.getCkbDirectEnd()));
		// 勤怠コメント
		dto.setTimeComment(vo.getTxtTimeComment());
		// 遅刻理由
		dto.setLateReason(vo.getPltLateReason());
		// 遅刻証明書
		dto.setLateCertificate(vo.getPltLateCertificate());
		// 遅刻コメント
		dto.setLateComment(vo.getTxtLateComment());
		// 早退理由
		dto.setLeaveEarlyReason(vo.getPltLeaveEarlyReason());
		// 早退証明書
		dto.setLeaveEarlyCertificate(vo.getPltLeaveEarlyCertificate());
		// 早退コメント
		dto.setLeaveEarlyComment(vo.getTxtLeaveEarlyComment());
	}
	
	/**
	 * VO(編集項目)の値をDTOに設定する。<br>
	 * @param dto 対象DTO
	 * @param num 手当てコード
	 * @throws MospException 例外発生時
	 */
	protected void setAllowanceDtoFields(AllowanceDtoInterface dto, int num) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// ■手当情報入力欄
		// 個人ID
		dto.setPersonalId(vo.getPersonalId());
		// 勤務日。
		dto.setWorkDate(vo.getTargetDate());
		// 勤務回数
		dto.setWorks(TimeBean.TIMES_WORK_DEFAULT);
		// 手当コード
		dto.setAllowanceCode(String.valueOf(num));
		// 手当
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INFO1)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance1()));
		}
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INFO2)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance2()));
		}
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INFO3)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance3()));
		}
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INFO4)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance4()));
		}
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INFO5)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance5()));
		}
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INFO6)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance6()));
		}
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INFO7)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance7()));
		}
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INFO8)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance8()));
		}
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INFO9)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance9()));
		}
		if (num == getInt(TimeConst.CODE_ALLOWANCE_CODE_INF10)) {
			dto.setAllowance(Integer.parseInt(vo.getPltAllowance10()));
		}
	}
	
	/**
	 * VO(編集項目)の値をDTOに設定する。<br>
	 * @param restList 休憩DTOのLIST
	 * @param dto 対象DTO
	 * @throws MospException 例外発生時
	 */
	protected void setRestFields(List<RestDtoInterface> restList, AttendanceDtoInterface dto) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 設定適用管理参照クラス取得
		ApplicationReferenceBeanInterface applicationReference = timeReference().application();
		// 勤怠設定参照クラス取得
		TimeSettingReferenceBeanInterface timeSettingReference = timeReference().timeSetting();
		// 自動計算インスタンス取得
		AttendanceCalcBeanInterface calc = time().attendanceCalc();
		// 適用されている設定を取得
		ApplicationDtoInterface applicationDto = applicationReference.findForPerson(vo.getPersonalId(), vo
			.getTargetDate());
		// 設定適用マスタの存在チェック
		applicationReference.chkExistApplication(applicationDto, vo.getTargetDate());
		if (mospParams.hasErrorMessage()) {
			return;
		}
		// 勤怠マスタ取得
		TimeSettingDtoInterface timeSettingDto = timeSettingReference.getTimeSettingInfo(applicationDto
			.getWorkSettingCode(), vo.getTargetDate());
		// 勤怠マスタの存在チェック
		timeSettingReference.chkExistTimeSetting(timeSettingDto, vo.getTargetDate());
		if (mospParams.hasErrorMessage()) {
			return;
		}
		Date startTime = dto.getStartTime();
		Date endTime = dto.getEndTime();
		// 勤怠データ休憩情報リスト取得
		List<RestDtoInterface> list = timeReference().rest().getRestList(vo.getPersonalId(), vo.getTargetDate(),
				TimeBean.TIMES_WORK_DEFAULT);
		// 休憩1の設定
		RestDtoInterface rest1Dto = getRestDto(1);
		if (vo.getTxtRestStartHour1() != null && !vo.getTxtRestStartHour1().isEmpty()) {
			Date restStart = getRest1Start();
			Date restEnd = getRest1End();
			if (startTime != null && restStart.before(startTime)) {
				// 休憩開始時刻が始業時刻より前の場合は始業時刻を休憩開始時刻とする
				restStart = startTime;
			}
			if (endTime != null && restEnd.after(endTime)) {
				// 休憩終了時刻が終業時刻より後の場合は終業時刻を休憩終了時刻とする
				restEnd = endTime;
			}
			if (restEnd.before(restStart)) {
				// 休憩終了時刻が休憩開始時刻より前の場合は休憩開始時刻を休憩終了時刻とする
				restEnd = restStart;
			}
			if (!restStart.equals(restEnd)) {
				// 休憩開始時刻
				rest1Dto.setRestStart(restStart);
				// 休憩終了時刻
				rest1Dto.setRestEnd(restEnd);
				Date roundRestStart = calc.getRoundMinute(restStart, timeSettingDto.getRoundDailyRestStart(),
						timeSettingDto.getRoundDailyRestStartUnit());
				Date roundRestEnd = calc.getRoundMinute(restEnd, timeSettingDto.getRoundDailyRestEnd(), timeSettingDto
					.getRoundDailyRestEndUnit());
				// 休憩時間。
				rest1Dto.setRestTime(calc.getRoundMinute(calc.getDefferenceMinutes(roundRestStart, roundRestEnd),
						timeSettingDto.getRoundDailyRestTime(), timeSettingDto.getRoundDailyRestTimeUnit()));
			}
		}
		// データが存在する場合、IDの追加
		if (list != null && 1 <= list.size()) {
			rest1Dto.setTmdRestId(list.get(0).getTmdRestId());
		}
		restList.add(rest1Dto);
		
		// 休憩2の設定
		RestDtoInterface rest2Dto = getRestDto(2);
		if (vo.getTxtRestStartHour2() != null && !vo.getTxtRestStartHour2().isEmpty()) {
			Date restStart = getRest2Start();
			Date restEnd = getRest2End();
			if (startTime != null && restStart.before(startTime)) {
				// 休憩開始時刻が始業時刻より前の場合は始業時刻を休憩開始時刻とする
				restStart = startTime;
			}
			if (endTime != null && restEnd.after(endTime)) {
				// 休憩終了時刻が終業時刻より後の場合は終業時刻を休憩終了時刻とする
				restEnd = endTime;
			}
			if (restEnd.before(restStart)) {
				// 休憩終了時刻が休憩開始時刻より前の場合は休憩開始時刻を休憩終了時刻とする
				restEnd = restStart;
			}
			if (!restStart.equals(restEnd)) {
				// 休憩開始時刻
				rest2Dto.setRestStart(restStart);
				// 休憩終了時刻
				rest2Dto.setRestEnd(restEnd);
				Date roundRestStart = calc.getRoundMinute(restStart, timeSettingDto.getRoundDailyRestStart(),
						timeSettingDto.getRoundDailyRestStartUnit());
				Date roundRestEnd = calc.getRoundMinute(restEnd, timeSettingDto.getRoundDailyRestEnd(), timeSettingDto
					.getRoundDailyRestEndUnit());
				// 休憩時間
				rest2Dto.setRestTime(calc.getRoundMinute(calc.getDefferenceMinutes(roundRestStart, roundRestEnd),
						timeSettingDto.getRoundDailyRestTime(), timeSettingDto.getRoundDailyRestTimeUnit()));
			}
		}
		// データが存在する場合、IDの追加
		if (list != null && 2 <= list.size()) {
			rest2Dto.setTmdRestId(list.get(1).getTmdRestId());
		}
		restList.add(rest2Dto);
		
		// 休憩3の設定
		RestDtoInterface rest3Dto = getRestDto(3);
		if (vo.getTxtRestStartHour3() != null && !vo.getTxtRestStartHour3().isEmpty()) {
			Date restStart = getRest3Start();
			Date restEnd = getRest3End();
			if (startTime != null && restStart.before(startTime)) {
				// 休憩開始時刻が始業時刻より前の場合は始業時刻を休憩開始時刻とする
				restStart = startTime;
			}
			if (endTime != null && restEnd.after(endTime)) {
				// 休憩終了時刻が終業時刻より後の場合は終業時刻を休憩終了時刻とする
				restEnd = endTime;
			}
			if (restEnd.before(restStart)) {
				// 休憩終了時刻が休憩開始時刻より前の場合は休憩開始時刻を休憩終了時刻とする
				restEnd = restStart;
			}
			if (!restStart.equals(restEnd)) {
				// 休憩開始時刻
				rest3Dto.setRestStart(restStart);
				// 休憩終了時刻
				rest3Dto.setRestEnd(restEnd);
				Date roundRestStart = calc.getRoundMinute(restStart, timeSettingDto.getRoundDailyRestStart(),
						timeSettingDto.getRoundDailyRestStartUnit());
				Date roundRestEnd = calc.getRoundMinute(restEnd, timeSettingDto.getRoundDailyRestEnd(), timeSettingDto
					.getRoundDailyRestEndUnit());
				// 休憩時間。
				rest3Dto.setRestTime(calc.getRoundMinute(calc.getDefferenceMinutes(roundRestStart, roundRestEnd),
						timeSettingDto.getRoundDailyRestTime(), timeSettingDto.getRoundDailyRestTimeUnit()));
			}
		}
		// データが存在する場合、IDの追加
		if (list != null && 3 <= list.size()) {
			rest3Dto.setTmdRestId(list.get(2).getTmdRestId());
		}
		restList.add(rest3Dto);
		
		// 休憩4の設定
		RestDtoInterface rest4Dto = getRestDto(4);
		if (vo.getTxtRestStartHour4() != null && !vo.getTxtRestStartHour4().isEmpty()) {
			Date restStart = getRest4Start();
			Date restEnd = getRest4End();
			if (startTime != null && restStart.before(startTime)) {
				// 休憩開始時刻が始業時刻より前の場合は始業時刻を休憩開始時刻とする
				restStart = startTime;
			}
			if (endTime != null && restEnd.after(endTime)) {
				// 休憩終了時刻が終業時刻より後の場合は終業時刻を休憩終了時刻とする
				restEnd = endTime;
			}
			if (restEnd.before(restStart)) {
				// 休憩終了時刻が休憩開始時刻より前の場合は休憩開始時刻を休憩終了時刻とする
				restEnd = restStart;
			}
			if (!restStart.equals(restEnd)) {
				// 休憩開始時刻
				rest4Dto.setRestStart(restStart);
				// 休憩終了時刻
				rest4Dto.setRestEnd(restEnd);
				// 丸めた時間を取得
				Date roundRestStart = calc.getRoundMinute(restStart, timeSettingDto.getRoundDailyRestStart(),
						timeSettingDto.getRoundDailyRestStartUnit());
				Date roundRestEnd = calc.getRoundMinute(restEnd, timeSettingDto.getRoundDailyRestEnd(), timeSettingDto
					.getRoundDailyRestEndUnit());
				// 休憩時間
				rest4Dto.setRestTime(calc.getRoundMinute(calc.getDefferenceMinutes(roundRestStart, roundRestEnd),
						timeSettingDto.getRoundDailyRestTime(), timeSettingDto.getRoundDailyRestTimeUnit()));
			}
		}
		// データが存在する場合、IDの追加
		if (list != null && 4 <= list.size()) {
			rest4Dto.setTmdRestId(list.get(3).getTmdRestId());
		}
		restList.add(rest4Dto);
		
		// 休憩5の設定
		RestDtoInterface rest5Dto = getRestDto(5);
		if (vo.getTxtRestStartHour5() != null && !vo.getTxtRestStartHour5().isEmpty()) {
			Date restStart = getRest5Start();
			Date restEnd = getRest5End();
			if (startTime != null && restStart.before(startTime)) {
				// 休憩開始時刻が始業時刻より前の場合は始業時刻を休憩開始時刻とする
				restStart = startTime;
			}
			if (endTime != null && restEnd.after(endTime)) {
				// 休憩終了時刻が終業時刻より後の場合は終業時刻を休憩終了時刻とする
				restEnd = endTime;
			}
			if (restEnd.before(restStart)) {
				// 休憩終了時刻が休憩開始時刻より前の場合は休憩開始時刻を休憩終了時刻とする
				restEnd = restStart;
			}
			if (!restStart.equals(restEnd)) {
				// 休憩開始時刻
				rest5Dto.setRestStart(restStart);
				// 休憩終了時刻
				rest5Dto.setRestEnd(restEnd);
				Date roundRestStart = calc.getRoundMinute(restStart, timeSettingDto.getRoundDailyRestStart(),
						timeSettingDto.getRoundDailyRestStartUnit());
				Date roundRestEnd = calc.getRoundMinute(restEnd, timeSettingDto.getRoundDailyRestEnd(), timeSettingDto
					.getRoundDailyRestEndUnit());
				// 休憩時間
				rest5Dto.setRestTime(calc.getRoundMinute(calc.getDefferenceMinutes(roundRestStart, roundRestEnd),
						timeSettingDto.getRoundDailyRestTime(), timeSettingDto.getRoundDailyRestTimeUnit()));
			}
		}
		// データが存在する場合、IDの追加
		if (list != null && 5 <= list.size()) {
			rest5Dto.setTmdRestId(list.get(4).getTmdRestId());
		}
		restList.add(rest5Dto);
		
		// 休憩6の設定
		RestDtoInterface rest6Dto = getRestDto(6);
		if (vo.getTxtRestStartHour6() != null && !vo.getTxtRestStartHour6().isEmpty()) {
			Date restStart = getRest6Start();
			Date restEnd = getRest6End();
			if (startTime != null && restStart.before(startTime)) {
				// 休憩開始時刻が始業時刻より前の場合は始業時刻を休憩開始時刻とする
				restStart = startTime;
			}
			if (endTime != null && restEnd.after(endTime)) {
				// 休憩終了時刻が終業時刻より後の場合は終業時刻を休憩終了時刻とする
				restEnd = endTime;
			}
			if (restEnd.before(restStart)) {
				// 休憩終了時刻が休憩開始時刻より前の場合は休憩開始時刻を休憩終了時刻とする
				restEnd = restStart;
			}
			if (!restStart.equals(restEnd)) {
				// 休憩開始時刻
				rest6Dto.setRestStart(restStart);
				// 休憩終了時刻
				rest6Dto.setRestEnd(restEnd);
				// 丸めた時間を取得
				Date roundRestStart = calc.getRoundMinute(restStart, timeSettingDto.getRoundDailyRestStart(),
						timeSettingDto.getRoundDailyRestStartUnit());
				Date roundRestEnd = calc.getRoundMinute(restEnd, timeSettingDto.getRoundDailyRestEnd(), timeSettingDto
					.getRoundDailyRestEndUnit());
				// 休憩時間
				rest6Dto.setRestTime(calc.getRoundMinute(calc.getDefferenceMinutes(roundRestStart, roundRestEnd),
						timeSettingDto.getRoundDailyRestTime(), timeSettingDto.getRoundDailyRestTimeUnit()));
			}
		}
		// データが存在する場合、IDの追加
		if (list != null && 6 <= list.size()) {
			rest6Dto.setTmdRestId(list.get(5).getTmdRestId());
		}
		restList.add(rest6Dto);
	}
	
	/**
	 * 休憩データDTOを取得する。<br>
	 * @param i 休憩回数
	 * @return 休憩データDTO
	 * @throws MospException 例外発生時
	 */
	protected RestDtoInterface getRestDto(int i) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		Date date = DateUtility.getDateTime(DateUtility.getYear(vo.getTargetDate()), DateUtility.getMonth(vo
			.getTargetDate()), DateUtility.getDay(vo.getTargetDate()), 0, 0);
		RestDtoInterface dto = time().restRegist().getInitDto();
		// 個人ID
		dto.setPersonalId(vo.getPersonalId());
		// 勤務日
		dto.setWorkDate(vo.getTargetDate());
		// 勤務回数
		dto.setTimesWork(TimeBean.TIMES_WORK_DEFAULT);
		// 休憩回数
		dto.setRest(i);
		// 休憩開始時刻
		dto.setRestStart(date);
		// 休憩終了時刻
		dto.setRestEnd(date);
		// 休憩時間
		dto.setRestTime(0);
		return dto;
	}
	
	/**
	 * VO(編集項目)の値をDTOに設定する。<br>
	 * @param publicList 公用DTOのLIST
	 * @param privateList 外用DTOのLIST
	 * @param startTime 始業時刻
	 * @param endTime 終業時刻
	 * @throws MospException 例外発生時
	 */
	protected void setGoOutDtoFields(List<GoOutDtoInterface> publicList, List<GoOutDtoInterface> privateList,
			Date startTime, Date endTime) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤怠データ外出情報登録クラス取得
		GoOutRegistBeanInterface regist = time().goOutRegist();
		// 自動計算インスタンス取得
		AttendanceCalcBeanInterface calc = time().attendanceCalc();
		// 勤怠設定情報取得
		TimeSettingDtoInterface timeSettingDto = timeReference().cutoffUtil().getTimeSetting(vo.getPersonalId(),
				vo.getTargetDate());
		// 処理結果確認
		if (mospParams.hasErrorMessage()) {
			return;
		}
		Date date = vo.getTargetDate();
		Date noDate = DateUtility.getDateTime(DateUtility.getYear(date), DateUtility.getMonth(date), DateUtility
			.getDay(date), 0, 0);
		// デフォルト勤務回数取得
		int timesWork = TimeBean.TIMES_WORK_DEFAULT;
		// 勤怠データ外出情報リスト取得
		List<GoOutDtoInterface> goOutPublicList = timeReference().goOut().getGoOutList(vo.getPersonalId(), date,
				timesWork, 1);
		List<GoOutDtoInterface> goOutPrivateList = timeReference().goOut().getGoOutList(vo.getPersonalId(), date,
				timesWork, 2);
		
		// 公用1の設定
		GoOutDtoInterface goOutPublic1Dto = regist.getInitDto();
		// 個人ID
		goOutPublic1Dto.setPersonalId(vo.getPersonalId());
		// 勤務日
		goOutPublic1Dto.setWorkDate(date);
		// 勤務回数
		goOutPublic1Dto.setTimesWork(timesWork);
		// 外出区分
		goOutPublic1Dto.setGoOutType(1);
		// 外出回数
		goOutPublic1Dto.setTimesGoOut(1);
		// 外出開始時刻
		goOutPublic1Dto.setGoOutStart(noDate);
		// 外出終了時刻
		goOutPublic1Dto.setGoOutEnd(noDate);
		// 外出時間
		goOutPublic1Dto.setGoOutTime(0);
		// 時刻設定
		if (vo.getTxtPublicStartHour1() != null && !vo.getTxtPublicStartHour1().isEmpty()) {
			Date goOutStart = getAttendanceTime(vo.getTxtPublicStartHour1(), vo.getTxtPublicStartMinute1());
			Date goOutEnd = getAttendanceTime(vo.getTxtPublicEndHour1(), vo.getTxtPublicEndMinute1());
			if (startTime != null && goOutStart.before(startTime)) {
				// 外出開始時刻が始業時刻より前の場合は始業時刻を外出開始時刻とする
				goOutStart = startTime;
			}
			if (endTime != null && goOutEnd.after(endTime)) {
				// 外出終了時刻が終業時刻より後の場合は終業時刻を外出終了時刻とする
				goOutEnd = endTime;
			}
			if (goOutEnd.before(goOutStart)) {
				// 外出終了時刻が外出開始時刻より前の場合は外出開始時刻を外出終了時刻とする
				goOutEnd = goOutStart;
			}
			if (!goOutStart.equals(goOutEnd)) {
				// 外出開始時刻。
				goOutPublic1Dto.setGoOutStart(goOutStart);
				// 外出終了時刻。
				goOutPublic1Dto.setGoOutEnd(goOutEnd);
				Date roundGoOutStart = calc.getRoundMinute(goOutStart, timeSettingDto.getRoundDailyPublicStart(),
						timeSettingDto.getRoundDailyPublicStartUnit());
				Date roundGoOutEnd = calc.getRoundMinute(goOutEnd, timeSettingDto.getRoundDailyPublicEnd(),
						timeSettingDto.getRoundDailyPublicEndUnit());
				// 外出時間。
				goOutPublic1Dto.setGoOutTime(calc.getDefferenceMinutes(roundGoOutStart, roundGoOutEnd));
			}
		}
		// データが存在する場合、IDの追加
		if (goOutPublicList != null && 1 <= goOutPublicList.size()) {
			goOutPublic1Dto.setTmdGoOutId(goOutPublicList.get(0).getTmdGoOutId());
		}
		publicList.add(goOutPublic1Dto);
		
		// 公用2の設定
		GoOutDtoInterface goOutPublic2Dto = regist.getInitDto();
		// 個人ID
		goOutPublic2Dto.setPersonalId(vo.getPersonalId());
		// 勤務日
		goOutPublic2Dto.setWorkDate(date);
		// 勤務回数
		goOutPublic2Dto.setTimesWork(timesWork);
		// 外出区分
		goOutPublic2Dto.setGoOutType(1);
		// 外出回数
		goOutPublic2Dto.setTimesGoOut(2);
		// 外出開始時刻
		goOutPublic2Dto.setGoOutStart(noDate);
		// 外出終了時刻
		goOutPublic2Dto.setGoOutEnd(noDate);
		// 外出時間
		goOutPublic2Dto.setGoOutTime(0);
		// 時刻設定
		if (vo.getTxtPublicStartHour2() != null && !vo.getTxtPublicStartHour2().isEmpty()) {
			Date goOutStart = getAttendanceTime(vo.getTxtPublicStartHour2(), vo.getTxtPublicStartMinute2());
			Date goOutEnd = getAttendanceTime(vo.getTxtPublicEndHour2(), vo.getTxtPublicEndMinute2());
			if (startTime != null && goOutStart.before(startTime)) {
				// 外出開始時刻が始業時刻より前の場合は始業時刻を外出開始時刻とする
				goOutStart = startTime;
			}
			if (endTime != null && goOutEnd.after(endTime)) {
				// 外出終了時刻が終業時刻より後の場合は終業時刻を外出終了時刻とする
				goOutEnd = endTime;
			}
			if (goOutEnd.before(goOutStart)) {
				// 外出終了時刻が外出開始時刻より前の場合は外出開始時刻を外出終了時刻とする
				goOutEnd = goOutStart;
			}
			if (!goOutStart.equals(goOutEnd)) {
				// 外出開始時刻
				goOutPublic2Dto.setGoOutStart(goOutStart);
				// 外出終了時刻
				goOutPublic2Dto.setGoOutEnd(goOutEnd);
				Date roundGoOutStart = calc.getRoundMinute(goOutStart, timeSettingDto.getRoundDailyPublicStart(),
						timeSettingDto.getRoundDailyPublicStartUnit());
				Date roundGoOutEnd = calc.getRoundMinute(goOutEnd, timeSettingDto.getRoundDailyPublicEnd(),
						timeSettingDto.getRoundDailyPublicEndUnit());
				// 外出時間
				goOutPublic2Dto.setGoOutTime(calc.getDefferenceMinutes(roundGoOutStart, roundGoOutEnd));
			}
		}
		// データが存在する場合、IDの追加
		if (goOutPublicList != null && 2 <= goOutPublicList.size()) {
			goOutPublic2Dto.setTmdGoOutId(goOutPublicList.get(1).getTmdGoOutId());
		}
		publicList.add(goOutPublic2Dto);
		// 私用1の設定
		GoOutDtoInterface goOutPrivate1Dto = regist.getInitDto();
		// 個人ID
		goOutPrivate1Dto.setPersonalId(vo.getPersonalId());
		// 勤務日
		goOutPrivate1Dto.setWorkDate(date);
		// 勤務回数
		goOutPrivate1Dto.setTimesWork(timesWork);
		// 外出区分
		goOutPrivate1Dto.setGoOutType(2);
		// 外出回数
		goOutPrivate1Dto.setTimesGoOut(1);
		// 外出開始時刻
		goOutPrivate1Dto.setGoOutStart(noDate);
		// 外出終了時刻
		goOutPrivate1Dto.setGoOutEnd(noDate);
		// 外出時間
		goOutPrivate1Dto.setGoOutTime(0);
		// 時刻設定
		if (vo.getTxtPrivateStartHour1() != null && !vo.getTxtPrivateStartHour1().isEmpty()) {
			Date goOutStart = getPrivate1Start();
			Date goOutEnd = getPrivate1End();
			if (startTime != null && goOutStart.before(startTime)) {
				// 外出開始時刻が始業時刻より前の場合は始業時刻を外出開始時刻とする
				goOutStart = startTime;
			}
			if (endTime != null && goOutEnd.after(endTime)) {
				// 外出終了時刻が終業時刻より後の場合は終業時刻を外出終了時刻とする
				goOutEnd = endTime;
			}
			if (goOutEnd.before(goOutStart)) {
				// 外出終了時刻が外出開始時刻より前の場合は外出開始時刻を外出終了時刻とする
				goOutEnd = goOutStart;
			}
			if (!goOutStart.equals(goOutEnd)) {
				// 外出開始時刻
				goOutPrivate1Dto.setGoOutStart(goOutStart);
				// 外出終了時刻
				goOutPrivate1Dto.setGoOutEnd(goOutEnd);
				Date roundGoOutStart = calc.getRoundMinute(goOutStart, timeSettingDto.getRoundDailyPrivateStart(),
						timeSettingDto.getRoundDailyPrivateStartUnit());
				Date roundGoOutEnd = calc.getRoundMinute(goOutEnd, timeSettingDto.getRoundDailyPrivateEnd(),
						timeSettingDto.getRoundDailyPrivateEndUnit());
				// 外出時間
				goOutPrivate1Dto.setGoOutTime(calc.getDefferenceMinutes(roundGoOutStart, roundGoOutEnd));
			}
		}
		// データが存在する場合、IDの追加
		if (goOutPrivateList != null && 1 <= goOutPrivateList.size()) {
			goOutPrivate1Dto.setTmdGoOutId(goOutPrivateList.get(0).getTmdGoOutId());
		}
		privateList.add(goOutPrivate1Dto);
		
		// 私用2の設定
		GoOutDtoInterface goOutPrivate2Dto = regist.getInitDto();
		// 個人ID
		goOutPrivate2Dto.setPersonalId(vo.getPersonalId());
		// 勤務日
		goOutPrivate2Dto.setWorkDate(date);
		// 勤務回数
		goOutPrivate2Dto.setTimesWork(timesWork);
		// 外出区分
		goOutPrivate2Dto.setGoOutType(2);
		// 外出回数
		goOutPrivate2Dto.setTimesGoOut(2);
		// 私用開始時刻
		goOutPrivate2Dto.setGoOutStart(noDate);
		// 私用終了時刻
		goOutPrivate2Dto.setGoOutEnd(noDate);
		// 外出時間
		goOutPrivate2Dto.setGoOutTime(0);
		// 時刻設定
		if (vo.getTxtPrivateStartHour2() != null && !vo.getTxtPrivateStartHour2().isEmpty()) {
			Date goOutStart = getPrivate2Start();
			Date goOutEnd = getPrivate2End();
			if (startTime != null && goOutStart.before(startTime)) {
				// 外出開始時刻が始業時刻より前の場合は始業時刻を外出開始時刻とする
				goOutStart = startTime;
			}
			if (endTime != null && goOutEnd.after(endTime)) {
				// 外出終了時刻が終業時刻より後の場合は終業時刻を外出終了時刻とする
				goOutEnd = endTime;
			}
			if (goOutEnd.before(goOutStart)) {
				// 外出終了時刻が外出開始時刻より前の場合は外出開始時刻を外出終了時刻とする
				goOutEnd = goOutStart;
			}
			if (!goOutStart.equals(goOutEnd)) {
				// 外出開始時刻。
				goOutPrivate2Dto.setGoOutStart(goOutStart);
				// 外出終了時刻。
				goOutPrivate2Dto.setGoOutEnd(goOutEnd);
				Date roundGoOutStart = calc.getRoundMinute(goOutStart, timeSettingDto.getRoundDailyPrivateStart(),
						timeSettingDto.getRoundDailyPrivateStartUnit());
				Date roundGoOutEnd = calc.getRoundMinute(goOutEnd, timeSettingDto.getRoundDailyPrivateEnd(),
						timeSettingDto.getRoundDailyPrivateEndUnit());
				// 外出時間。
				goOutPrivate2Dto.setGoOutTime(calc.getDefferenceMinutes(roundGoOutStart, roundGoOutEnd));
			}
		}
		// データが存在する場合、IDの追加
		if (goOutPrivateList != null && 2 <= goOutPrivateList.size()) {
			goOutPrivate2Dto.setTmdGoOutId(goOutPrivateList.get(1).getTmdGoOutId());
		}
		privateList.add(goOutPrivate2Dto);
	}
	
	/**
	 * 休憩/公用外出/私用外出重複チェック。<br>
	 * @throws MospException 例外発生時
	 */
	protected void restCheck() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 始業時刻
		int startTimeHour = 0;
		if (vo.getTxtStartTimeHour().length() != 0) {
			startTimeHour = Integer.parseInt(vo.getTxtStartTimeHour());
		}
		int startTimeMinute = 0;
		if (vo.getTxtStartTimeMinute().length() != 0) {
			startTimeMinute = Integer.parseInt(vo.getTxtStartTimeMinute());
		}
		// 終業時刻
		int endTimeHour = 0;
		if (vo.getTxtEndTimeHour().length() != 0) {
			endTimeHour = Integer.parseInt(vo.getTxtEndTimeHour());
		}
		int endTimeMinute = 0;
		if (vo.getTxtEndTimeMinute().length() != 0) {
			endTimeMinute = Integer.parseInt(vo.getTxtEndTimeMinute());
		}
		// 休憩1
		int restStartTime1Hour = 0;
		if (vo.getTxtRestStartHour1().length() != 0) {
			restStartTime1Hour = Integer.parseInt(vo.getTxtRestStartHour1());
		}
		int restStartTime1Minute = 0;
		if (vo.getTxtRestStartMinute1().length() != 0) {
			restStartTime1Minute = Integer.parseInt(vo.getTxtRestStartMinute1());
		}
		int restEndTime1Hour = 0;
		if (vo.getTxtRestEndHour1().length() != 0) {
			restEndTime1Hour = Integer.parseInt(vo.getTxtRestEndHour1());
		}
		int restEndTime1Minute = 0;
		if (vo.getTxtRestEndMinute1().length() != 0) {
			restEndTime1Minute = Integer.parseInt(vo.getTxtRestEndMinute1());
		}
		// 休憩2
		int restStartTime2Hour = 0;
		if (vo.getTxtRestStartHour2().length() != 0) {
			restStartTime2Hour = Integer.parseInt(vo.getTxtRestStartHour2());
		}
		int restStartTime2Minute = 0;
		if (vo.getTxtRestStartMinute2().length() != 0) {
			restStartTime2Minute = Integer.parseInt(vo.getTxtRestStartMinute2());
		}
		int restEndTime2Hour = 0;
		if (vo.getTxtRestEndHour2().length() != 0) {
			restEndTime2Hour = Integer.parseInt(vo.getTxtRestEndHour2());
		}
		int restEndTime2Minute = 0;
		if (vo.getTxtRestEndMinute2().length() != 0) {
			restEndTime2Minute = Integer.parseInt(vo.getTxtRestEndMinute2());
		}
		// 休憩3
		int restStartTime3Hour = 0;
		if (vo.getTxtRestStartHour3().length() != 0) {
			restStartTime3Hour = Integer.parseInt(vo.getTxtRestStartHour3());
		}
		int restStartTime3Minute = 0;
		if (vo.getTxtRestStartMinute3().length() != 0) {
			restStartTime3Minute = Integer.parseInt(vo.getTxtRestStartMinute3());
		}
		int restEndTime3Hour = 0;
		if (vo.getTxtRestEndHour3().length() != 0) {
			restEndTime3Hour = Integer.parseInt(vo.getTxtRestEndHour3());
		}
		int restEndTime3Minute = 0;
		if (vo.getTxtRestEndMinute3().length() != 0) {
			restEndTime3Minute = Integer.parseInt(vo.getTxtRestEndMinute3());
		}
		// 休憩4
		int restStartTime4Hour = 0;
		if (vo.getTxtRestStartHour4().length() != 0) {
			restStartTime4Hour = Integer.parseInt(vo.getTxtRestStartHour4());
		}
		int restStartTime4Minute = 0;
		if (vo.getTxtRestStartMinute4().length() != 0) {
			restStartTime4Minute = Integer.parseInt(vo.getTxtRestStartMinute4());
		}
		int restEndTime4Hour = 0;
		if (vo.getTxtRestEndHour4().length() != 0) {
			restEndTime4Hour = Integer.parseInt(vo.getTxtRestEndHour4());
		}
		int restEndTime4Minute = 0;
		if (vo.getTxtRestEndMinute4().length() != 0) {
			restEndTime4Minute = Integer.parseInt(vo.getTxtRestEndMinute4());
		}
		// 休憩5
		int restStartTime5Hour = 0;
		if (vo.getTxtRestStartHour5().length() != 0) {
			restStartTime5Hour = Integer.parseInt(vo.getTxtRestStartHour5());
		}
		int restStartTime5Minute = 0;
		if (vo.getTxtRestStartMinute5().length() != 0) {
			restStartTime5Minute = Integer.parseInt(vo.getTxtRestStartMinute5());
		}
		int restEndTime5Hour = 0;
		if (vo.getTxtRestEndHour5().length() != 0) {
			restEndTime5Hour = Integer.parseInt(vo.getTxtRestEndHour5());
		}
		int restEndTime5Minute = 0;
		if (vo.getTxtRestEndMinute5().length() != 0) {
			restEndTime5Minute = Integer.parseInt(vo.getTxtRestEndMinute5());
		}
		// 休憩6
		int restStartTime6Hour = 0;
		if (vo.getTxtRestStartHour6().length() != 0) {
			restStartTime6Hour = Integer.parseInt(vo.getTxtRestStartHour6());
		}
		int restStartTime6Minute = 0;
		if (vo.getTxtRestStartMinute6().length() != 0) {
			restStartTime6Minute = Integer.parseInt(vo.getTxtRestStartMinute6());
		}
		int restEndTime6Hour = 0;
		if (vo.getTxtRestEndHour6().length() != 0) {
			restEndTime6Hour = Integer.parseInt(vo.getTxtRestEndHour6());
		}
		int restEndTime6Minute = 0;
		if (vo.getTxtRestEndMinute6().length() != 0) {
			restEndTime6Minute = Integer.parseInt(vo.getTxtRestEndMinute6());
		}
		// 公用外出1
		int publicStartTime1Hour = 0;
		if (vo.getTxtPublicStartHour1().length() != 0) {
			publicStartTime1Hour = Integer.parseInt(vo.getTxtPublicStartHour1());
		}
		int publicStartTime1Minute = 0;
		if (vo.getTxtPublicStartMinute1().length() != 0) {
			publicStartTime1Minute = Integer.parseInt(vo.getTxtPublicStartMinute1());
		}
		int publicEndTime1Hour = 0;
		if (vo.getTxtPublicEndHour1().length() != 0) {
			publicEndTime1Hour = Integer.parseInt(vo.getTxtPublicEndHour1());
		}
		int publicEndTime1Minute = 0;
		if (vo.getTxtPublicEndMinute1().length() != 0) {
			publicEndTime1Minute = Integer.parseInt(vo.getTxtPublicEndMinute1());
		}
		// 公用外出2
		int publicStartTime2Hour = 0;
		if (vo.getTxtPublicStartHour2().length() != 0) {
			publicStartTime2Hour = Integer.parseInt(vo.getTxtPublicStartHour2());
		}
		int publicStartTime2Minute = 0;
		if (vo.getTxtPublicStartMinute2().length() != 0) {
			publicStartTime2Minute = Integer.parseInt(vo.getTxtPublicStartMinute2());
		}
		int publicEndTime2Hour = 0;
		if (vo.getTxtPublicEndHour2().length() != 0) {
			publicEndTime2Hour = Integer.parseInt(vo.getTxtPublicEndHour2());
		}
		int publicEndTime2Minute = 0;
		if (vo.getTxtPublicEndMinute2().length() != 0) {
			publicEndTime2Minute = Integer.parseInt(vo.getTxtPublicEndMinute2());
		}
		// 私用外出1
		int privateStartTime1Hour = 0;
		if (vo.getTxtPrivateStartHour1().length() != 0) {
			privateStartTime1Hour = Integer.parseInt(vo.getTxtPrivateStartHour1());
		}
		int privateStartTime1Minute = 0;
		if (vo.getTxtPrivateStartMinute1().length() != 0) {
			privateStartTime1Minute = Integer.parseInt(vo.getTxtPrivateStartMinute1());
		}
		int privateEndTime1Hour = 0;
		if (vo.getTxtPrivateEndHour1().length() != 0) {
			privateEndTime1Hour = Integer.parseInt(vo.getTxtPrivateEndHour1());
		}
		int privateEndTime1Minute = 0;
		if (vo.getTxtPrivateEndMinute1().length() != 0) {
			privateEndTime1Minute = Integer.parseInt(vo.getTxtPrivateEndMinute1());
		}
		// 私用外出2
		int privateStartTime2Hour = 0;
		if (vo.getTxtPrivateStartHour2().length() != 0) {
			privateStartTime2Hour = Integer.parseInt(vo.getTxtPrivateStartHour2());
		}
		int privateStartTime2Minute = 0;
		if (vo.getTxtPrivateStartMinute2().length() != 0) {
			privateStartTime2Minute = Integer.parseInt(vo.getTxtPrivateStartMinute2());
		}
		int privateEndTime2Hour = 0;
		if (vo.getTxtPrivateEndHour2().length() != 0) {
			privateEndTime2Hour = Integer.parseInt(vo.getTxtPrivateEndHour2());
		}
		int privateEndTime2Minute = 0;
		if (vo.getTxtPrivateEndMinute2().length() != 0) {
			privateEndTime2Minute = Integer.parseInt(vo.getTxtPrivateEndMinute2());
		}
		int[] aryStartTimeHour = { restStartTime1Hour, restStartTime2Hour, restStartTime3Hour, restStartTime4Hour,
			restStartTime5Hour, restStartTime6Hour, publicStartTime1Hour, publicStartTime2Hour, privateStartTime1Hour,
			privateStartTime2Hour };
		int[] aryStartTimeMinute = { restStartTime1Minute, restStartTime2Minute, restStartTime3Minute,
			restStartTime4Minute, restStartTime5Minute, restStartTime6Minute, publicStartTime1Minute,
			publicStartTime2Minute, privateStartTime1Minute, privateStartTime2Minute };
		int[] aryEndTimeHour = { restEndTime1Hour, restEndTime2Hour, restEndTime3Hour, restEndTime4Hour,
			restEndTime5Hour, restEndTime6Hour, publicEndTime1Hour, publicEndTime2Hour, privateEndTime1Hour,
			privateEndTime2Hour };
		int[] aryEndTimeMinute = { restEndTime1Minute, restEndTime2Minute, restEndTime3Minute, restEndTime4Minute,
			restEndTime5Minute, restEndTime6Minute, publicEndTime1Minute, publicEndTime2Minute, privateEndTime1Minute,
			privateEndTime2Minute };
		// エラーメッセージの設定
		String errMes = mospParams.getName("RestTime") + mospParams.getName("Slash") + mospParams.getName("GoingOut")
				+ mospParams.getName("Time");
		
		// 始業/終業時間チェック
		if (startTimeHour > endTimeHour) {
			mospParams.addErrorMessage(TimeMessageConst.MSG_START_END_TIME_CHECK, null, null);
			return;
		} else if (startTimeHour == endTimeHour) {
			if (startTimeMinute >= endTimeMinute) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_START_END_TIME_CHECK, null, null);
				return;
			}
		}
		for (int i = 0; i < aryStartTimeHour.length; i++) {
			// 時分がすべて0(未入力)なのでチェックしない
			if (aryStartTimeHour[i] == 0 && aryStartTimeMinute[i] == 0 && aryEndTimeHour[i] == 0
					&& aryEndTimeMinute[i] == 0) {
				continue;
			}
			if (startTimeHour > aryStartTimeHour[i]) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_WORK_TIME_OUT_CHECK, errMes, null);
				return;
			} else if (startTimeHour == aryStartTimeHour[i]) {
				if (startTimeMinute > aryStartTimeMinute[i]) {
					mospParams.addErrorMessage(TimeMessageConst.MSG_WORK_TIME_OUT_CHECK, errMes, null);
					return;
				}
			}
			if (endTimeHour < aryEndTimeHour[i]) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_WORK_TIME_OUT_CHECK, errMes, null);
				return;
			} else if (endTimeHour == aryEndTimeHour[i]) {
				if (endTimeMinute < aryEndTimeMinute[i]) {
					mospParams.addErrorMessage(TimeMessageConst.MSG_WORK_TIME_OUT_CHECK, errMes, null);
					return;
				}
			}
		}
		// 時間重複チェック
		for (int i = 0; i < aryStartTimeHour.length; i++) {
			// 時分がすべて0(未入力)なのでチェックしない
			if (aryStartTimeHour[i] == 0 && aryStartTimeMinute[i] == 0 && aryEndTimeHour[i] == 0
					&& aryEndTimeMinute[i] == 0) {
				continue;
			}
			for (int j = i; j < aryStartTimeHour.length; j++) {
				if (i == j) {
					continue;
				}
				// 時分がすべて0(未入力)なのでチェックしない
				if (aryStartTimeHour[j] == 0 && aryStartTimeMinute[j] == 0 && aryEndTimeHour[j] == 0
						&& aryEndTimeMinute[j] == 0) {
					continue;
				}
				if (aryEndTimeHour[i] > aryStartTimeHour[j]) {
					mospParams.addErrorMessage(TimeMessageConst.MSG_REST_GOING_OUT_CHECK, errMes, null);
					return;
				} else if (aryEndTimeHour[i] == aryStartTimeHour[j]) {
					if (aryEndTimeMinute[i] > aryStartTimeMinute[j]) {
						mospParams.addErrorMessage(TimeMessageConst.MSG_REST_GOING_OUT_CHECK, errMes, null);
						return;
					}
				}
			}
		}
		return;
	}
	
	/**
	 * 休憩時間チェック。
	 * @param dto 勤怠データ情報
	 * @throws MospException 例外発生時
	 */
	private void chkRest(AttendanceDtoInterface dto) throws MospException {
		boolean checkRest1 = false;
		boolean checkRest2 = false;
		boolean checkRest3 = false;
		boolean checkRest4 = false;
		boolean checkRest5 = false;
		boolean checkRest6 = false;
		// 勤務形態コードがない場合
		if (dto.getWorkTypeCode() == null || dto.getWorkTypeCode().isEmpty()) {
			return;
		}
		// 法定休出又は所定休出の場合
		if (TimeConst.CODE_WORK_ON_LEGAL_HOLIDAY.equals(dto.getWorkTypeCode())
				|| TimeConst.CODE_WORK_ON_PRESCRIBED_HOLIDAY.equals(dto.getWorkTypeCode())) {
			return;
		}
		Date workStartTime = null;
		Date workEndTime = null;
		// 勤務形態コードが時差出勤区分A,B,C,D,Sの場合
		if (dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_A)
				|| dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_B)
				|| dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_C)
				|| dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_D)
				|| dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_S)) {
			// 時差出勤申請からレコードを取得
			DifferenceRequestDtoInterface differenceRequestDto = timeReference().differenceRequest()
				.findForKeyOnWorkflow(dto.getPersonalId(), dto.getWorkDate());
			// 時差出勤申請情報が存在する場合
			if (differenceRequestDto != null) {
				// 最新のワークフロー取得
				WorkflowDtoInterface workflow = reference().workflow().getLatestWorkflowInfo(
						differenceRequestDto.getWorkflow());
				// 承認済である場合
				if (workflow != null && PlatformConst.CODE_STATUS_COMPLETE.equals(workflow.getWorkflowStatus())) {
					// 時差出勤開始時刻取得
					workStartTime = differenceRequestDto.getRequestStart();
					// 時差出勤開始時刻取得
					workEndTime = differenceRequestDto.getRequestEnd();
					checkRest2 = true;
					checkRest3 = true;
					checkRest4 = true;
					checkRest5 = true;
					checkRest6 = true;
				}
			}
		}
		if (workStartTime == null || workEndTime == null) {
			// 時差出勤でない場合
			WorkTypeDtoInterface workTypeDto = timeReference().workType().findForInfo(dto.getWorkTypeCode(),
					dto.getWorkDate());
			if (workTypeDto == null) {
				return;
			}
			WorkTypeItemDtoInterface workStart = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_WORKSTART);
			WorkTypeItemDtoInterface workEnd = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_WORKEND);
			Date standardDate = DateUtility.getTime(0, 0);
			workStartTime = getAttendanceTime(DateUtility.getHour(workStart.getWorkTypeItemValue(), standardDate),
					DateUtility.getMinute(workEnd.getWorkTypeItemValue()));
			workEndTime = getAttendanceTime(DateUtility.getHour(workEnd.getWorkTypeItemValue(), standardDate),
					DateUtility.getMinute(workEnd.getWorkTypeItemValue()));
			WorkTypeItemDtoInterface rest1Start = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_RESTSTART1);
			WorkTypeItemDtoInterface rest1End = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_RESTEND1);
			if (standardDate.equals(rest1Start.getWorkTypeItemValue())
					&& standardDate.equals(rest1End.getWorkTypeItemValue())) {
				checkRest1 = true;
			}
			WorkTypeItemDtoInterface rest2Start = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_RESTSTART2);
			WorkTypeItemDtoInterface rest2End = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_RESTEND2);
			if (standardDate.equals(rest2Start.getWorkTypeItemValue())
					&& standardDate.equals(rest2End.getWorkTypeItemValue())) {
				checkRest2 = true;
			}
			WorkTypeItemDtoInterface rest3Start = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_RESTSTART3);
			WorkTypeItemDtoInterface rest3End = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_RESTEND3);
			if (standardDate.equals(rest3Start.getWorkTypeItemValue())
					&& standardDate.equals(rest3End.getWorkTypeItemValue())) {
				checkRest3 = true;
			}
			WorkTypeItemDtoInterface rest4Start = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_RESTSTART4);
			WorkTypeItemDtoInterface rest4End = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_RESTEND4);
			if (standardDate.equals(rest4Start.getWorkTypeItemValue())
					&& standardDate.equals(rest4End.getWorkTypeItemValue())) {
				checkRest4 = true;
			}
			checkRest5 = true;
			checkRest6 = true;
		}
		if (checkRest1) {
			// 休憩1
			chkRest(getRest1Start(), getRest1End(), workStartTime, workEndTime, mospParams.getName("Rest1"));
			if (mospParams.hasErrorMessage()) {
				return;
			}
		}
		if (checkRest2) {
			// 休憩2
			chkRest(getRest2Start(), getRest2End(), workStartTime, workEndTime, mospParams.getName("Rest2"));
			if (mospParams.hasErrorMessage()) {
				return;
			}
		}
		if (checkRest3) {
			// 休憩3
			chkRest(getRest3Start(), getRest3End(), workStartTime, workEndTime, mospParams.getName("Rest3"));
			if (mospParams.hasErrorMessage()) {
				return;
			}
		}
		if (checkRest4) {
			// 休憩4
			chkRest(getRest4Start(), getRest4End(), workStartTime, workEndTime, mospParams.getName("Rest4"));
			if (mospParams.hasErrorMessage()) {
				return;
			}
		}
		if (checkRest5) {
			// 休憩5
			chkRest(getRest5Start(), getRest5End(), workStartTime, workEndTime, mospParams.getName("Rest5"));
			if (mospParams.hasErrorMessage()) {
				return;
			}
		}
		if (checkRest6) {
			// 休憩6
			chkRest(getRest6Start(), getRest6End(), workStartTime, workEndTime, mospParams.getName("Rest6"));
		}
	}
	
	/**
	 * 休憩時間の範囲チェック。
	 * @param restStart 休憩開始日
	 * @param restEnd 休憩終了日
	 * @param workStart 勤務開始日
	 * @param workEnd 勤務終了日
	 * @param restName 休憩名称
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	private void chkRest(Date restStart, Date restEnd, Date workStart, Date workEnd, String restName)
			throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		Date targetDate = vo.getTargetDate();
		Date defaultTime = DateUtility.getDateTime(DateUtility.getYear(targetDate), DateUtility.getMonth(targetDate),
				DateUtility.getDay(targetDate), 0, 0);
		if (restStart == null || restEnd == null || (defaultTime.equals(restStart) && defaultTime.equals(restEnd))
				|| (!restStart.after(workStart) && !restEnd.after(workStart))
				|| (!restStart.before(workEnd) && !restEnd.before(workEnd))) {
			return;
		}
		StringBuffer sb = new StringBuffer();
		sb.append(mospParams.getName("Prescribed"));
		sb.append(mospParams.getName("Labor"));
		sb.append(mospParams.getName("Time"));
		// エラーメッセージ追加
		mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_OUTSIDE_CHECK, restName, sb.toString());
	}
	
	/**
	 * 私用外出チェック。
	 * @param dto 勤怠データ情報
	 * @throws MospException インスタンスの取得或いはSQL実行に失敗した場合
	 */
	private void chkPrivateGoOut(AttendanceDtoInterface dto) throws MospException {
		if (dto.getWorkTypeCode() == null || dto.getWorkTypeCode().isEmpty()) {
			return;
		}
		// 私用外出名取得
		String goingOut = mospParams.getName("PrivateGoingOut");
		StringBuffer prescribedWorkTime = new StringBuffer();
		prescribedWorkTime.append(mospParams.getName("Prescribed"));
		prescribedWorkTime.append(mospParams.getName("Labor"));
		prescribedWorkTime.append(mospParams.getName("Time"));
		// 勤務日取得
		Date defaultTime = DateUtility.getDateTime(DateUtility.getYear(dto.getWorkDate()), DateUtility.getMonth(dto
			.getWorkDate()), DateUtility.getDay(dto.getWorkDate()), 0, 0);
		// 私用外出1開始時刻を取得
		Date private1Start = getPrivate1Start();
		if (private1Start == null) {
			private1Start = defaultTime;
		}
		// 私用外出1終了時刻を取得
		Date private1End = getPrivate1End();
		if (private1End == null) {
			private1End = defaultTime;
		}
		// 私用外出2開始時刻を取得
		Date private2Start = getPrivate2Start();
		if (private2Start == null) {
			private2Start = defaultTime;
		}
		// 私用外出2終了時刻を取得
		Date private2End = getPrivate2End();
		if (private2End == null) {
			private2End = defaultTime;
		}
		// 法定休日労働又は所定休日労働の場合
		if (TimeConst.CODE_WORK_ON_LEGAL_HOLIDAY.equals(dto.getWorkTypeCode())
				|| TimeConst.CODE_WORK_ON_PRESCRIBED_HOLIDAY.equals(dto.getWorkTypeCode())) {
			// 私用外出1時刻、 私用外出2事項が勤務日と違う場合
			if (!defaultTime.equals(private1Start) || !defaultTime.equals(private1End)
					|| !defaultTime.equals(private2Start) || !defaultTime.equals(private2End)) {
				// エラーメッセージ追加
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_INSIDE_CHECK, goingOut, prescribedWorkTime
					.toString());
				return;
			}
		}
		Date workStartTime = null;
		Date workEndTime = null;
		if (dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_A)
				|| dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_B)
				|| dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_C)
				|| dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_D)
				|| dto.getWorkTypeCode().equals(TimeConst.CODE_DIFFERENCE_TYPE_S)) {
			DifferenceRequestDtoInterface differenceRequestDto = timeReference().differenceRequest()
				.findForKeyOnWorkflow(dto.getPersonalId(), dto.getWorkDate());
			if (differenceRequestDto != null) {
				WorkflowDtoInterface workflow = reference().workflow().getLatestWorkflowInfo(
						differenceRequestDto.getWorkflow());
				if (workflow != null && PlatformConst.CODE_STATUS_COMPLETE.equals(workflow.getWorkflowStatus())) {
					workStartTime = differenceRequestDto.getRequestStart();
					workEndTime = differenceRequestDto.getRequestEnd();
				}
			}
		}
		if (workStartTime == null || workEndTime == null) {
			// 時差出勤でない場合
			WorkTypeDtoInterface workTypeDto = timeReference().workType().findForInfo(dto.getWorkTypeCode(),
					dto.getWorkDate());
			if (workTypeDto == null) {
				return;
			}
			// 勤務形態項目取得
			WorkTypeItemDtoInterface workStart = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_WORKSTART);
			WorkTypeItemDtoInterface workEnd = timeReference().workTypeItem().getWorkTypeItemInfo(
					workTypeDto.getWorkTypeCode(), workTypeDto.getActivateDate(), TimeConst.CODE_WORKEND);
			Date standardDate = DateUtility.getTime(0, 0);
			workStartTime = getAttendanceTime(DateUtility.getHour(workStart.getWorkTypeItemValue(), standardDate),
					DateUtility.getMinute(workEnd.getWorkTypeItemValue()));
			workEndTime = getAttendanceTime(DateUtility.getHour(workEnd.getWorkTypeItemValue(), standardDate),
					DateUtility.getMinute(workEnd.getWorkTypeItemValue()));
		}
		Date[][] privateTimeArray = new Date[][]{ { private1Start, private1End }, { private2Start, private2End } };
		for (Date[] timeArray : privateTimeArray) {
			Date start = timeArray[0];
			Date end = timeArray[1];
			if ((start == null || end == null) || (defaultTime.equals(start) && defaultTime.equals(end))) {
				continue;
			} else if (start.before(workStartTime) || end.after(workEndTime)) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_INSIDE_CHECK, goingOut, prescribedWorkTime
					.toString());
				return;
			}
		}
	}
	
	/**
	 * @param hour 時
	 * @param minute 分
	 * @return 日付
	 * @throws MospException 例外発生時
	 */
	protected Date getAttendanceTime(String hour, String minute) throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		if (hour.isEmpty() || minute.isEmpty()) {
			return null;
		}
		return time().attendanceCalc().getAttendanceTime(vo.getTargetDate(), hour, minute);
	}
	
	/**
	 * @param hour 時
	 * @param minute 分
	 * @return 日付
	 * @throws MospException 例外発生時
	 */
	protected Date getAttendanceTime(int hour, int minute) throws MospException {
		return getAttendanceTime(Integer.toString(hour), Integer.toString(minute));
	}
	
	/**
	 * 休憩1開始時刻を取得する。<br>
	 * @return 休憩1開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest1Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestStartHour1(), vo.getTxtRestStartMinute1());
	}
	
	/**
	 * 休憩1終了時刻を取得する。<br>
	 * @return 休憩1終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest1End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestEndHour1(), vo.getTxtRestEndMinute1());
	}
	
	/**
	 * 休憩2開始時刻を取得する。<br>
	 * @return 休憩2開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest2Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestStartHour2(), vo.getTxtRestStartMinute2());
	}
	
	/**
	 * 休憩2終了時刻を取得する。<br>
	 * @return 休憩2終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest2End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestEndHour2(), vo.getTxtRestEndMinute2());
	}
	
	/**
	 * 休憩3開始時刻を取得する。<br>
	 * @return 休憩3開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest3Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestStartHour3(), vo.getTxtRestStartMinute3());
	}
	
	/**
	 * 休憩3終了時刻を取得する。<br>
	 * @return 休憩3終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest3End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestEndHour3(), vo.getTxtRestEndMinute3());
	}
	
	/**
	 * 休憩4開始時刻を取得する。<br>
	 * @return 休憩4開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest4Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestStartHour4(), vo.getTxtRestStartMinute4());
	}
	
	/**
	 * 休憩4終了時刻を取得する。<br>
	 * @return 休憩4終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest4End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestEndHour4(), vo.getTxtRestEndMinute4());
	}
	
	/**
	 * 休憩5開始時刻を取得する。<br>
	 * @return 休憩5開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest5Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestStartHour5(), vo.getTxtRestStartMinute5());
	}
	
	/**
	 * 休憩5終了時刻を取得する。<br>
	 * @return 休憩5終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest5End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestEndHour5(), vo.getTxtRestEndMinute5());
	}
	
	/**
	 * 休憩6開始時刻を取得する。<br>
	 * @return 休憩6開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest6Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestStartHour6(), vo.getTxtRestStartMinute6());
	}
	
	/**
	 * 休憩6終了時刻を取得する。<br>
	 * @return 休憩6終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getRest6End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtRestEndHour6(), vo.getTxtRestEndMinute6());
	}
	
	/**
	 * 私用外出1開始時刻を取得する。<br>
	 * @return 私用外出1開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getPrivate1Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtPrivateStartHour1(), vo.getTxtPrivateStartMinute1());
	}
	
	/**
	 * 私用外出1終了時刻を取得する。<br>
	 * @return 私用外出1終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getPrivate1End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtPrivateEndHour1(), vo.getTxtPrivateEndMinute1());
	}
	
	/**
	 * 私用外出2開始時刻を取得する。<br>
	 * @return 私用外出2開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getPrivate2Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtPrivateStartHour2(), vo.getTxtPrivateStartMinute2());
	}
	
	/**
	 * 私用外出2終了時刻を取得する。<br>
	 * @return 私用外出2終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getPrivate2End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtPrivateEndHour2(), vo.getTxtPrivateEndMinute2());
	}
	
	/**
	 * 公用外出1開始時刻を取得する。<br>
	 * @return 公用外出1開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getPublic1Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtPublicStartHour1(), vo.getTxtPublicStartMinute1());
	}
	
	/**
	 * 公用外出1終了時刻を取得する。<br>
	 * @return 公用外出1終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getPublic1End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtPublicEndHour1(), vo.getTxtPublicEndMinute1());
	}
	
	/**
	 * 公用外出2開始時刻を取得する。<br>
	 * @return 公用外出2開始時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getPublic2Start() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtPublicStartHour2(), vo.getTxtPublicStartMinute2());
	}
	
	/**
	 * 公用外出2終了時刻を取得する。<br>
	 * @return 公用外出2終了時刻
	 * @throws MospException 例外発生時
	 */
	protected Date getPublic2End() throws MospException {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getAttendanceTime(vo.getTxtPublicEndHour2(), vo.getTxtPublicEndMinute2());
	}
	
	/**
	 * 勤務形態及び勤務形態プルダウン用配列を設定する。<br>
	 * プルダウンには、長さ1の配列が設定される。<br>
	 * @param workTypeCode 勤務形態コード
	 * @param workTypeName 勤務形態名称
	 */
	protected void setPltWorkType(String workTypeCode, String workTypeName) {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤務形態設定
		vo.setPltWorkType(workTypeCode);
		// 配列準備
		String[][] aryPltWorkType = { { workTypeCode, workTypeName } };
		// プルダウン設定
		vo.setAryPltWorkType(aryPltWorkType);
	}
	
	/**
	 * 勤務形態及び勤務形態プルダウン用配列を設定する。<br>
	 * プルダウンには、長さ1の配列が設定される。<br>
	 * 勤務形態は空白とする。<br>
	 * 有給休暇等、存在しない勤務形態を設定する場合に用いる。<br>
	 * @param workTypeName 勤務形態名称
	 */
	protected void setPltWorkType(String workTypeName) {
		// VO準備
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		// 勤務形態設定
		vo.setPltWorkType("");
		// 配列準備
		String[][] aryPltWorkType = { { "", workTypeName } };
		// プルダウン設定
		vo.setAryPltWorkType(aryPltWorkType);
	}
	
	/**
	 * 勤務形態プルダウン用配列を取得する。<br>
	 * @param patternCode パターンコード
	 * @return 勤務形態プルダウン用配列
	 * @throws MospException 例外発生時
	 */
	protected String[][] getWorkTypeArray(String patternCode) throws MospException {
		// VO取得
		AttendanceCardVo vo = (AttendanceCardVo)mospParams.getVo();
		return getWorkTypeArray(patternCode, vo.getTargetDate(), false, true);
	}
	
	/**
	 * 追加処理を行う。
	 * VOの値を汎用マスタ情報に詰める。
	 * @throws MospException 例外発生時
	 */
	protected void setGeneralDtoFields() throws MospException {
		// アドオン機能などで処理
	}
	
	/**
	 * 休暇時間の重複チェック
	 * @throws MospException 例外発生時
	 */
	protected void chkDuplRest() throws MospException {
		Date baseDateStart = null;
		Date baseDateEnd = null;
		// 昼休憩
		baseDateStart = getRest1Start();
		baseDateEnd = getRest1End();
		if (baseDateStart != null && baseDateEnd != null) {
			// 時間外休憩2
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest2Start(), getRest2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest1"),
						mospParams.getName("Rest2"));
				return;
			}
			// 時間外休憩3
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest3Start(), getRest3End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest1"),
						mospParams.getName("Rest3"));
				return;
			}
			// 時間外休憩4
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest4Start(), getRest4End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest1"),
						mospParams.getName("Rest4"));
				return;
			}
			// 時間外休憩5
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest5Start(), getRest5End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest1"),
						mospParams.getName("Rest5"));
				return;
			}
			// 時間外休憩6
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest6Start(), getRest6End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest1"),
						mospParams.getName("Rest6"));
				return;
			}
			// 公用外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic1Start(), getPublic1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest1"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No1"));
				return;
			}
			// 公用外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic2Start(), getPublic2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest1"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No2"));
				return;
			}
			// 時間内外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate1Start(), getPrivate1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest1"),
						mospParams.getName("PrivateGoingOut1"));
				return;
			}
			// 時間内外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate2Start(), getPrivate2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest1"),
						mospParams.getName("PrivateGoingOut2"));
				return;
			}
		}
		
		// 時間外休憩2	
		baseDateStart = getRest2Start();
		baseDateEnd = getRest2End();
		if (baseDateStart != null && baseDateEnd != null) {
			// 時間外休憩3
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest3Start(), getRest3End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest2"),
						mospParams.getName("Rest3"));
				return;
			}
			// 時間外休憩4
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest4Start(), getRest4End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest2"),
						mospParams.getName("Rest4"));
				return;
			}
			// 時間外休憩5
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest5Start(), getRest5End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest2"),
						mospParams.getName("Rest5"));
				return;
			}
			// 時間外休憩6
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest6Start(), getRest6End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest2"),
						mospParams.getName("Rest6"));
				return;
			}
			// 公用外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic1Start(), getPublic1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest2"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No1"));
				return;
			}
			// 公用外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic2Start(), getPublic2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest2"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No2"));
				return;
			}
			// 時間内外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate1Start(), getPrivate1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest2"),
						mospParams.getName("PrivateGoingOut1"));
				return;
			}
			// 時間内外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate2Start(), getPrivate2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest2"),
						mospParams.getName("PrivateGoingOut2"));
				return;
			}
		}
		
		// 時間外休憩3	
		baseDateStart = getRest3Start();
		baseDateEnd = getRest3End();
		if (baseDateStart != null && baseDateEnd != null) {
			// 時間外休憩4
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest4Start(), getRest4End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest3"),
						mospParams.getName("Rest4"));
				return;
			}
			// 時間外休憩5
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest5Start(), getRest5End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest3"),
						mospParams.getName("Rest5"));
				return;
			}
			// 時間外休憩6
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest6Start(), getRest6End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest3"),
						mospParams.getName("Rest6"));
				return;
			}
			// 公用外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic1Start(), getPublic1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest3"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No1"));
				return;
			}
			// 公用外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic2Start(), getPublic2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest3"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No2"));
				return;
			}
			// 時間内外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate1Start(), getPrivate1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest3"),
						mospParams.getName("PrivateGoingOut1"));
				return;
			}
			// 時間内外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate2Start(), getPrivate2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest3"),
						mospParams.getName("PrivateGoingOut2"));
				return;
			}
		}
		
		// 時間外休憩4	
		baseDateStart = getRest4Start();
		baseDateEnd = getRest4End();
		if (baseDateStart != null && baseDateEnd != null) {
			// 時間外休憩5
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest5Start(), getRest5End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest4"),
						mospParams.getName("Rest5"));
				return;
			}
			// 時間外休憩6
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest6Start(), getRest6End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest4"),
						mospParams.getName("Rest6"));
				return;
			}
			// 公用外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic1Start(), getPublic1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest4"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No1"));
				return;
			}
			// 公用外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic2Start(), getPublic2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest4"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No2"));
				return;
			}
			// 時間内外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate1Start(), getPrivate1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest4"),
						mospParams.getName("PrivateGoingOut1"));
				return;
			}
			// 時間内外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate2Start(), getPrivate2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest4"),
						mospParams.getName("PrivateGoingOut2"));
				return;
			}
		}
		// 時間外休憩5	
		baseDateStart = getRest5Start();
		baseDateEnd = getRest5End();
		if (baseDateStart != null && baseDateEnd != null) {
			// 時間外休憩6
			if (chkDuplTime(baseDateStart, baseDateEnd, getRest6Start(), getRest6End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest5"),
						mospParams.getName("Rest6"));
				return;
			}
			// 公用外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic1Start(), getPublic1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest5"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No1"));
				return;
			}
			// 公用外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic2Start(), getPublic2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest5"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No2"));
				return;
			}
			// 時間内外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate1Start(), getPrivate1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest5"),
						mospParams.getName("PrivateGoingOut1"));
				return;
			}
			// 時間内外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate2Start(), getPrivate2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest5"),
						mospParams.getName("PrivateGoingOut2"));
				return;
			}
		}
		
		//	時間外休憩6	
		baseDateStart = getRest6Start();
		baseDateEnd = getRest6End();
		if (baseDateStart != null && baseDateEnd != null) {
			// 公用外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic1Start(), getPublic1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest6"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No1"));
				return;
			}
			// 公用外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic2Start(), getPublic2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest6"),
						mospParams.getName("Official") + mospParams.getName("GoingOut") + mospParams.getName("No2"));
				return;
			}
			// 時間内外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate1Start(), getPrivate1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest6"),
						mospParams.getName("PrivateGoingOut1"));
				return;
			}
			// 時間内外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate2Start(), getPrivate2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Rest6"),
						mospParams.getName("PrivateGoingOut2"));
				return;
			}
		}
		
		// 公用外出1	
		baseDateStart = getPublic1Start();
		baseDateEnd = getPublic1End();
		if (baseDateStart != null && baseDateEnd != null) {
			// 公用外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPublic2Start(), getPublic2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Official")
						+ mospParams.getName("GoingOut") + mospParams.getName("No1"), mospParams.getName("Official")
						+ mospParams.getName("GoingOut") + mospParams.getName("No2"));
				return;
			}
			// 時間内外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate1Start(), getPrivate1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Official")
						+ mospParams.getName("GoingOut") + mospParams.getName("No1"), mospParams
					.getName("PrivateGoingOut1"));
				return;
			}
			// 時間内外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate2Start(), getPrivate2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Official")
						+ mospParams.getName("GoingOut") + mospParams.getName("No1"), mospParams
					.getName("PrivateGoingOut2"));
				return;
			}
		}
		
		// 公用外出2	
		baseDateStart = getPublic2Start();
		baseDateEnd = getPublic2End();
		if (baseDateStart != null && baseDateEnd != null) {
			// 時間内外出1
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate1Start(), getPrivate1End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Official")
						+ mospParams.getName("GoingOut") + mospParams.getName("No2"), mospParams
					.getName("PrivateGoingOut1"));
				return;
			}
			// 時間内外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate2Start(), getPrivate2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams.getName("Official")
						+ mospParams.getName("GoingOut") + mospParams.getName("No2"), mospParams
					.getName("PrivateGoingOut2"));
				return;
			}
		}
		
		// 時間内外出1	
		baseDateStart = getPrivate1Start();
		baseDateEnd = getPrivate1End();
		if (baseDateStart != null && baseDateEnd != null) {
			// 時間内外出2
			if (chkDuplTime(baseDateStart, baseDateEnd, getPrivate2Start(), getPrivate2End())) {
				mospParams.addErrorMessage(TimeMessageConst.MSG_TIME_DUPLICATION_CHECK, mospParams
					.getName("PrivateGoingOut1"), mospParams.getName("PrivateGoingOut2"));
				return;
			}
		}
	}
	
	/**
	 * 時間の重複チェック
	 * @param bStart 対象の開始時間
	 * @param bEnd 対象の終了時間
	 * @param aStart 比べる先の開始時間
	 * @param aEnd 比べる先の終了時間
	 * @return true 時間の重複あり：false 時間の重複無し
	 */
	protected boolean chkDuplTime(Date bStart, Date bEnd, Date aStart, Date aEnd) {
		if (aStart != null && aEnd != null) {
			return bEnd.after(aStart) && bStart.before(aEnd);
		}
		return false;
	}
}
