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

import java.sql.SQLException;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import jp.mosp.common.CommonConst;
import jp.mosp.common.common.MospConst;
import jp.mosp.common.common.MospException;
import jp.mosp.common.common.MospUtility;
import jp.mosp.common.dto.KintaiCommonDtoInterface;
import jp.mosp.common.part.MosPCodePart;
import jp.mosp.common.part.PartInfo;
import jp.mosp.common.utils.DateUtil;
import jp.mosp.common.utils.NumberUtil;
import jp.mosp.common.utils.StringUtil;
import jp.mosp.common.utils.VariousUtil;
import jp.mosp.kintai.dto.MSyukkinboDto;
import jp.mosp.kintai.payroll.dao.KdWorkDao;
import jp.mosp.kintai.payroll.dto.KdWorkDto;
import jp.mosp.mospcommon.system.AgreementBaseInfo;
import jp.mosp.payroll.dao.CompileAmendmentDao;
import jp.mosp.payroll.dao.MKintaiDao;
import jp.mosp.payroll.dao.MKintaiKinmuDao;
import jp.mosp.payroll.dto.CompileAmendmentDto;
import jp.mosp.payroll.dto.KintaiCompileDto;
import jp.mosp.payroll.dto.MKintaiDto;
import jp.mosp.payroll.dto.MKintaiKinmuDto;

/**
 * 勤怠集計用Partクラス
 * @author yoshida
 *	@version	0.0.8
 */
public class KintaiCompilePart extends KintaiBasePart {
	
	/**
	 * M_KINTAI
	 */
	public static final String	KINTAI_TABLE		= MKintaiDao.TABLE;
	
	/**
	 * KD_WORK
	 */
	public static final String	KINTAI_NEW_TABLE	= KdWorkDao.TABLE;
	

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

	/**
	 * MKintaiDaoインスタンス
	 */
	private MKintaiDao	kintaiDao;
	

	/**
	 * 勤怠集計テーブル用DAOの取得
	 * @since	0.0.3
	 * @return	初期化済みMKintaiDaoインスタンス
	 * @throws Exception	例外処理が発生した場合
	 */
	public MKintaiDao getMKintaiDao() throws Exception {
		if (VariousUtil.isNull(kintaiDao)) {
			kintaiDao = (MKintaiDao)getPreparedDao(MKintaiDao.class.getCanonicalName());
		}
		return kintaiDao;
	}
	

	/**
	 * MKintaiKinmuDaoインスタンス
	 */
	private MKintaiKinmuDao	kinmuDao;
	

	/**
	 * 勤務形態別勤怠集計テーブル用DAOの取得
	 * @since	0.0.3
	 * @return	初期化済みMKintaiKinmuDaoインスタンス
	 * @throws Exception	例外処理が発生した場合
	 */
	public MKintaiKinmuDao getMKintaiKinmuDao() throws Exception {
		if (VariousUtil.isNull(kinmuDao)) {
			kinmuDao = (MKintaiKinmuDao)getPreparedDao(MKintaiKinmuDao.class.getCanonicalName());
		}
		return kinmuDao;
	}
	

	/**
	 * CompileAmendmentDaoインスタンス
	 */
	private CompileAmendmentDao	amendmentDao;
	

	/**
	 * 勤怠集計用DAOの取得
	 * @since	0.0.5
	 * @return	初期化済みCompileAmendmentDaoインスタンス
	 * @throws Exception	例外処理が発生した場合
	 */
	public CompileAmendmentDao getCompileAmendmentDao() throws Exception {
		if (VariousUtil.isNull(amendmentDao)) {
			amendmentDao = (CompileAmendmentDao)getPreparedDao(CompileAmendmentDao.class.getCanonicalName());
		}
		return amendmentDao;
	}
	

	private KdWorkDao	kdWorkDao;
	

	/**
	 * 勤怠集計用DAOの取得
	 * @return 初期化済みKdWorkDaoインスタンス
	 * @throws MospException 	MosP例外処理が発生した場合
	 */
	public KdWorkDao getKdWorkDao() throws MospException {
		if (VariousUtil.isNull(kdWorkDao)) {
			kdWorkDao = (KdWorkDao)getPreparedDao(KdWorkDao.class.getCanonicalName());
		}
		return kdWorkDao;
	}
	
	/**
	 * 勤怠集計情報（旧）取得
	 * @param kCode 対象社員コード
	 * @param yearMonth 対象年月
	 * @return 勤怠集計情報（旧）
	 * @throws Exception  	例外処理が発生した場合
	 */
	public MKintaiDto getKintaiInfo(String kCode, Date yearMonth) throws Exception {
		return getMKintaiDao().findForKey(kCode, DateUtil.convDateToStringYearMonthShort(yearMonth));
	}
	
	/**
	 * 勤怠集計情報（旧）取得
	 * @param kCode 対象社員コード
	 * @param year 対象年
	 * @param month 対象月
	 * @return 勤怠集計情報（旧）
	 * @throws Exception  	例外処理が発生した場合
	 */
	public MKintaiDto getKintaiInfo(String kCode, int year, int month) throws Exception {
		return getKintaiInfo(kCode, DateUtil.getYearMonth(year, month));
	}
	
	/**
	 * 勤怠集計情報（新）取得
	 * @param kCode 対象社員コード
	 * @param yearMonth 対象年月
	 * @return 勤怠集計情報（新）
	 * @throws SQLException SQL例外が発生した場合
	 * @throws IllegalAccessException	メソッドにアクセスできない場合
	 * @throws NoSuchFieldException	フィールドが見つからなかった場合
	 * @throws MospException 	MosP例外処理が発生した場合
	 */
	public KdWorkDto getKdWorkInfo(String kCode, Date yearMonth) throws SQLException, IllegalAccessException,
			NoSuchFieldException, MospException {
		return getKdWorkDao().findForKey(kCode, DateUtil.convDateToStringYearMonthShort(yearMonth));
	}
	
	/**
	 * 勤怠集計情報（新）取得
	 * @param kCode 対象社員コード
	 * @param year 対象年
	 * @param month 対象月
	 * @return 勤怠集計情報（新）
	 * @throws SQLException SQL例外が発生した場合
	 * @throws IllegalAccessException	メソッドにアクセスできない場合
	 * @throws NoSuchFieldException	フィールドが見つからなかった場合
	 * @throws MospException 	MosP例外処理が発生した場合
	 */
	public KdWorkDto getKdWorkInfo(String kCode, String year, String month) throws SQLException,
			IllegalAccessException, NoSuchFieldException, MospException {
		return getKdWorkInfo(kCode, DateUtil.getYearMonth(year, month));
	}
	
	/**
	 * 勤怠集計情報（新）取得
	 * @param kCode 対象社員コード
	 * @param year 対象年
	 * @param month 対象月
	 * @return 勤怠集計情報（新）
	 * @throws SQLException SQL例外が発生した場合
	 * @throws IllegalAccessException	メソッドにアクセスできない場合
	 * @throws NoSuchFieldException	フィールドが見つからなかった場合
	 * @throws MospException 	MosP例外処理が発生した場合
	 */
	public KdWorkDto getKdWorkInfo(String kCode, int year, int month) throws SQLException, IllegalAccessException,
			NoSuchFieldException, MospException {
		return getKdWorkInfo(kCode, DateUtil.getYearMonth(year, month));
	}
	
	/**
	 * 対象出勤簿・予定簿リスト勤怠集計情報取得
	 * @param kCode				対象社員コード
	 * @param attendanceList	対象年月出勤簿・予定簿リスト
	 * @param useApprovalFunction	勤怠承認機能フラグ
	 * @return	出勤簿・予定簿リスト勤怠集計情報
	 * @throws Exception	例外処理が発生した場合
	 */
	public KintaiCompileDto getCompiledInfo(String kCode, List<?> attendanceList, boolean useApprovalFunction)
			throws Exception {
		// 改正労働基準法に対応
		return getReformCompiledInfo(kCode, attendanceList, useApprovalFunction);
	}
	
	/**
	 * 対象年月勤怠集計情報変換
	 * @param kCode			対象社員コード
	 * @param targetMonth	対象年月日
	 * @param dto			対象年月勤怠集計情報DTO
	 * @return	勤怠集計情報
	 * @throws Exception	例外処理が発生した場合
	 */
	public MKintaiDto convCompileToKintai(String kCode, Date targetMonth, KintaiCompileDto dto) throws Exception {
		// DTOの初期化
		MKintaiDto kintaiDto = new MKintaiDto();
		// DTOに値をセット
		margeKintaiAndCompile(kCode, targetMonth, part().calculate().getCalcPayment(targetMonth), kintaiDto, dto);
		return kintaiDto;
	}
	
	/**
	 * 対象年月勤怠集計情報変換
	 * @param kCode			対象社員コード
	 * @param targetMonth	対象年月日
	 * @param dto			対象年月勤怠集計情報DTO
	 * @return	勤怠集計情報
	 * @throws Exception	例外処理が発生した場合
	 */
	public KdWorkDto convNewCompileToKintai(String kCode, Date targetMonth, KintaiCompileDto dto) throws Exception {
		// DTOの初期化
		KdWorkDto kdWorkDto = new KdWorkDto();
		// DTOに値をセット
		margeKdWorkAndCompile(kCode, targetMonth, part().calculate().getCalcPayment(targetMonth), kdWorkDto, dto);
		return kdWorkDto;
	}
	
	/**
	 * 対象年月勤怠集計情報マージ
	 * @param kCode 	対象社員コード
	 * @param targetMonth 対象年月
	 * @param paymentDate 支給年月日
	 * @param kintaiDto 対象DTO
	 * @param compileDto 対象年月勤怠集計情報DTO
	 */
	public static void margeKintaiAndCompile(String kCode, Date targetMonth, Date paymentDate, MKintaiDto kintaiDto,
			KintaiCompileDto compileDto) {
		MKintaiDto dto = kintaiDto;
		if (VariousUtil.isNotNull(kintaiDto)) {
			// 社員コード
			dto.setKCode(kCode);
			// 支給年月
			dto.setSikyuYM(DateUtil.convDateToStringYearMonthShort(targetMonth));
			// 支給年
			dto.setSNen(MospUtility.getYear(paymentDate));
			// 支給月
			dto.setSTuki(MospUtility.getMonth(paymentDate));
			// 支給日
			dto.setSHi(MospUtility.getDay(paymentDate));
			if (VariousUtil.isNotNull(compileDto)) {
				// 出勤日数
				dto.setSNissu(compileDto.getTotalWorkDays());
				// 出勤回数
				dto.setSKaisu(compileDto.getTotalWorkNumber());
				// 勤務時間合計
				dto.setKinmuJi(compileDto.getTotalWork());
				// 休憩時間合計
				dto.setKyukeiJi(compileDto.getTotalInterbal());
				// 有給休暇日数
				dto.setYukyu(compileDto.getTotalPaidHoliday());
				// 特別休暇日数
				dto.setTokuKyu(compileDto.getTotalParticularHoliday());
				// 欠勤休暇日数
				dto.setKekkin(compileDto.getTotalAbsence());
				// 傷病休暇日数
				dto.setSKekkin(compileDto.getTotalMedicalLeave());
				// 代休日数
				dto.setDaiKyu(compileDto.getTotalCompensationDay());
				// 振替休暇日数
				dto.setFurikae(compileDto.getTotalTransfer());
				// その他休暇数
				double totalOther = compileDto.getTotalOther();
				totalOther += compileDto.getTotalKkRiyuu6();
				totalOther += compileDto.getTotalKkRiyuu7();
				totalOther += compileDto.getTotalKkRiyuu8();
				totalOther += compileDto.getTotalKkRiyuu9();
				// 其他休暇日数
				dto.setSonota(Double.valueOf(totalOther).intValue());
				// 遅刻早退数
				dto.setTiSoKai(compileDto.getLeaveAndLate());
				// 遅刻早退時間合計
				dto.setTiJikan(compileDto.getTotalLeaveAndLate());
				// 残業時間合計
				dto.setZaJikan(compileDto.getTotalOver());
				// 休出時間合計
				dto.setKsJikan(compileDto.getTotalHolidayWork());
				// 深夜時間合計
				dto.setSnJikan(compileDto.getTotalLateNight());
				// 皆勤
				dto.setKaikin(0);
				if (compileDto.isApplyAttendanceAllowance()) {
					dto.setKaikin(1);
				}
				// 手当
				// 食事手当合計
				dto.setSyokujiKaisu(compileDto.getSyokuji());
				// １直手当合計
				dto.setCyokuKaisu1(compileDto.getCyoku1());
				// ２直手当合計
				dto.setCyokuKaisu2(compileDto.getCyoku2());
				// ３直手当合計
				dto.setCyokuKaisu3(compileDto.getCyoku3());
				// その他手当１合計
				dto.setHokaKaisu1(compileDto.getHoka1());
				// その他手当２合計
				dto.setHokaKaisu2(compileDto.getHoka2());
				// その他手当３合計
				dto.setHokaKaisu3(compileDto.getHoka3());
				// その他手当４合計
				dto.setHokaKaisu4(compileDto.getHoka4());
				// その他手当５合計
				dto.setHokaKaisu5(compileDto.getHoka5());
				// 時間単位年休合計
				dto.setNijiKyu(compileDto.getUnitHourHoliday());
				// 1.00割増
				dto.setWarimasi1(compileDto.getWarimasi1());
			}
		}
	}
	
	/**
	 * 勤怠集計情報（旧）をKintaiCompileDtoへ変換
	 * @param dto 対象DTO
	 * @return 変換後勤怠集計情報
	 */
	public static KintaiCompileDto convKintaiToCompile(MKintaiDto dto) {
		KintaiCompileDto compileDto = new KintaiCompileDto();
		if (VariousUtil.isNotNull(dto)) {
			// 出勤日数
			compileDto.setTotalWorkDays(dto.getSNissu());
			// 出勤回数
			compileDto.setTotalWorkNumber(dto.getSKaisu());
			// 勤務時間合計
			compileDto.setTotalWork(dto.getKinmuJi());
			// 休憩時間合計
			compileDto.setTotalInterbal(dto.getKyukeiJi());
			// 有給休暇日数
			compileDto.setTotalPaidHoliday(dto.getYukyu());
			// 特別休暇日数
			compileDto.setTotalParticularHoliday(dto.getTokuKyu());
			// 欠勤休暇日数
			compileDto.setTotalAbsence(dto.getKekkin());
			// 傷病休暇日数
			compileDto.setTotalMedicalLeave(dto.getSKekkin());
			// 代休日数
			compileDto.setTotalCompensationDay(dto.getDaiKyu());
			// 振替休暇日数
			compileDto.setTotalTransfer(dto.getFurikae());
			// 其他休暇日数
			compileDto.setTotalOther(dto.getSonota());
			// 遅刻早退数
			compileDto.setLeaveAndLate(dto.getTiSoKai());
			// 遅刻早退時間合計
			compileDto.setTotalLeaveAndLate(dto.getTiJikan());
			// 残業時間合計
			compileDto.setTotalOver(dto.getZaJikan());
			// 休出時間合計
			compileDto.setTotalHolidayWork(dto.getKsJikan());
			// 深夜時間合計
			compileDto.setTotalLateNight(dto.getSnJikan());
			// 皆勤
			compileDto.setApplyAttendanceAllowance(StringUtil.isFlagOn(String.valueOf(dto.getKaikin())));
			// 手当
			// 食事手当合計
			compileDto.setSyokuji(dto.getSyokujiKaisu());
			// １直手当合計
			compileDto.setCyoku1(dto.getCyokuKaisu1());
			// ２直手当合計
			compileDto.setCyoku2(dto.getCyokuKaisu2());
			// ３直手当合計
			compileDto.setCyoku3(dto.getCyokuKaisu3());
			// その他手当１合計
			compileDto.setHoka1(dto.getHokaKaisu1());
			// その他手当２合計
			compileDto.setHoka2(dto.getHokaKaisu2());
			// その他手当３合計
			compileDto.setHoka3(dto.getHokaKaisu3());
			// その他手当４合計
			compileDto.setHoka4(dto.getHokaKaisu4());
			// その他手当５合計
			compileDto.setHoka5(dto.getHokaKaisu5());
			// 時間単位年休合計
			compileDto.setUnitHourHoliday(dto.getNijiKyu());
			// 1.00割増
			compileDto.setWarimasi1(dto.getWarimasi1());
		}
		return compileDto;
	}
	
	/**
	 * 勤怠月集計
	 * @param kCode				対象社員コード
	 * @param targetMonth		対象年月
	 * @param attendanceList 	対象年月出勤簿・予定簿リスト
	 * @return	勤怠月集計
	 * @throws Exception	例外処理が発生した場合
	 */
	public MKintaiDto getCompiledInfo(String kCode, Date targetMonth, List<?> attendanceList) throws Exception {
		// 対象年月勤怠集計情報
		return convCompileToKintai(kCode, targetMonth, getCompiledInfo(kCode, attendanceList, part().mospcode()
			.isAttendanceApprovalFunction()));
	}
	
	/**
	 * 勤怠月集計
	 * @param kCode				対象社員コード
	 * @param targetMonth		対象年月
	 * @param attendanceList 	対象年月出勤簿・予定簿リスト
	 * @return	勤怠月集計
	 * @throws Exception	例外処理が発生した場合
	 */
	public KdWorkDto getNewCompiledInfo(String kCode, Date targetMonth, List<?> attendanceList) throws Exception {
		// 対象年月勤怠集計情報
		return convNewCompileToKintai(kCode, targetMonth, getCompiledInfo(kCode, attendanceList, part().mospcode()
			.isAttendanceApprovalFunction()));
	}
	
	/**
	 * 承認・未承認件数作成
	 * @param attendanceList 	対象年月出勤簿・予定簿リスト
	 * @since	0.0.2
	 * @return [0]…承認件数、[1]…未承認件数、[2]…出勤件数
	 */
	public static int[] makeApprovalNumber(List<MSyukkinboDto> attendanceList) {
		// 配列初期化
		int[] number = { 0, 0, 0 };
		// 出勤件数
		number[2] = attendanceList.size();
		for (MSyukkinboDto dto : attendanceList) {
			// 一次承認、二次承認
			if (KintaiApprovalPart.is2ndApproved(dto)) {
				number[0]++;
			} else {
				number[1]++;
			}
		}
		return number;
	}
	
	/**
	 * 勤怠集計情報取得
	 * @param kCode		対象社員コード
	 * @param yearMonth 対象年月
	 * @param sCode		対象所属コード
	 * @return	勤怠集計情報
	 * @throws Exception	例外処理が発生した場合
	 */
	public CompileAmendmentDto getCompileAmendmentInfo(String kCode, Date yearMonth, String sCode) throws Exception {
		String sikyuYM = DateUtil.convDateToStringYearMonthShort(yearMonth);
		if (MosPCodePart.afterLegalReformDate(yearMonth)) {
			if (DateUtil.getLegalReformDate().compareTo(yearMonth) == 0) {
				// 2010年4月の場合
				if (part().calculate().getMinusMonth() == 0) {
					// 勤怠締日が当月の場合
					return getCompileAmendmentDao().findForNewTable(kCode, sikyuYM, sCode);
				} else {
					// 勤怠締日が前月の場合
					return getCompileAmendmentDao().findForCondition(kCode, sikyuYM, sCode);
				}
			} else {
				// 2010年5月以降
				return getCompileAmendmentDao().findForNewTable(kCode, sikyuYM, sCode);
			}
		} else {
			return getCompileAmendmentDao().findForCondition(kCode, sikyuYM, sCode);
		}
	}
	
	/**
	 * 未承認有無検索
	 * @since	0.0.6
	 * @param attendanceList	対象年月出勤簿・予定簿リスト
	 * @return true…未承認無し、false…未承認有り
	 */
	public static boolean checkApproval(List<MSyukkinboDto> attendanceList) {
		// 承認・未承認件数作成
		int[] number = makeApprovalNumber(attendanceList);
		if (number[2] > 0) {
			// 未承認件数
			return number[1] == 0;
		} else if (number[2] == 0) {
			// 出勤件数が0の場合
			return true;
		}
		return false;
	}
	
	/**
	 * 勤務形態別勤怠月集計
	 * @since	0.0.7
	 * @param kCode			対象社員コード
	 * @param targetMonth	対象年月
	 * @param workType		対象勤務形態コード
	 * @param attendanceList 	対象年月出勤簿・予定簿リスト
	 * @param inputUnit 入力単位
	 * @return	mKinmuDto	集計済み勤務形態別集計DTO
	 * @throws Exception  　例外処理が発生した場合
	 */
	public MKintaiKinmuDto getCompileForWorkType(String kCode, Date targetMonth, String workType,
			List<?> attendanceList, int inputUnit) throws Exception {
		MKintaiKinmuDto kinmuDto = new MKintaiKinmuDto();
		// 変数宣言、変数の初期化
		// 残業時間計
		int totalOver = 0;
		// 深夜時間計
		int totalLateNight = 0;
		// 休出時間計
		int totalHolidayWork = 0;
		// 出勤日数計
		int totalWorkDays = 0;
		// 手当
		int syokuji = 0;
		int cyoku1 = 0;
		int cyoku2 = 0;
		int cyoku3 = 0;
		int hoka1 = 0;
		int hoka2 = 0;
		int hoka3 = 0;
		int hoka4 = 0;
		int hoka5 = 0;
		// 集計開始
		for (Object obj : attendanceList) {
			KintaiCommonDtoInterface dto = (KintaiCommonDtoInterface)obj;
			// 勤怠項目
			if (dto.getKinmu().equals(workType)) {
				// 残業時間
				totalOver += dto.getZaJikan();
				// 深夜時間
				totalLateNight += dto.getSnJikan();
				// 休出時間
				totalHolidayWork += dto.getKsJikan();
				// 出勤日数
				if (dto.getKinmuJi() > 0) {
					totalWorkDays++;
				}
				// 手当
				syokuji += dto.getSyokuji();
				cyoku1 += dto.getCyoku1();
				cyoku2 += dto.getCyoku2();
				cyoku3 += dto.getCyoku3();
				hoka1 += dto.getHoka1();
				hoka2 += dto.getHoka2();
				hoka3 += dto.getHoka3();
				hoka4 += dto.getHoka4();
				hoka5 += dto.getHoka5();
			}
		}
		// 丸め処理判断
		if (part().kintai().isRoundNumberMonthly()) {
			// 勤怠集計時に丸め処理を行う。
			// 残業時間合計
			totalOver = NumberUtil.roundIntegerNumber(totalWorkDays, inputUnit);
			// 深夜時間合計
			totalLateNight = NumberUtil.roundIntegerNumber(totalLateNight, inputUnit);
			// 休出時間合計
			totalHolidayWork = NumberUtil.roundIntegerNumber(totalHolidayWork, inputUnit);
		}
		// DTOに値をセット
		kinmuDto.setKCode(kCode);
		// 支給年月
		kinmuDto.setSikyuYM(DateUtil.convDateToStringYearMonthShort(targetMonth));
		// 勤務形態コード
		kinmuDto.setKinmu(workType);
		// 出勤日数
		kinmuDto.setSNissu(totalWorkDays);
		// 残業時間合計
		kinmuDto.setZaJikan(totalOver);
		// 深夜時間合計
		kinmuDto.setSZJikan(totalLateNight);
		// 休出時間合計
		kinmuDto.setHSJikan(totalHolidayWork);
		// 手当
		// 食事手当合計
		kinmuDto.setSyokuji(syokuji);
		// １直手当合計
		kinmuDto.setCyoku1(cyoku1);
		// ２直手当合計
		kinmuDto.setCyoku2(cyoku2);
		// ３直手当合計
		kinmuDto.setCyoku3(cyoku3);
		// その他手当１合計
		kinmuDto.setHoka1(hoka1);
		// その他手当２合計
		kinmuDto.setHoka2(hoka2);
		// その他手当３合計
		kinmuDto.setHoka3(hoka3);
		// その他手当４合計
		kinmuDto.setHoka4(hoka4);
		// その他手当５合計
		kinmuDto.setHoka5(hoka5);
		return kinmuDto;
	}
	
	/**
	 * 対象年月の勤怠集計リスト
	 * @param year 対象年
	 * @param month 対象月
	 * @return 対象年月の勤怠集計リスト
	 * @throws SQLException SQL例外が発生した場合
	 * @throws IllegalAccessException メソッドにアクセスできない場合
	 * @throws NoSuchFieldException フィールドが見つからなかった場合
	 * @throws MospException MosP例外処理が発生した場合
	 */
	public List<KdWorkDto> getKdWorkList(int year, int month) throws SQLException, IllegalAccessException,
			NoSuchFieldException, MospException {
		return getKdWorkList(String.valueOf(year), String.valueOf(month));
		
	}
	
	/**
	 * 対象年月の勤怠集計リスト
	 * @param year 対象年
	 * @param month 対象月
	 * @return 対象年月の勤怠集計リスト
	 * @throws SQLException SQL例外が発生した場合
	 * @throws IllegalAccessException メソッドにアクセスできない場合
	 * @throws NoSuchFieldException フィールドが見つからなかった場合
	 * @throws MospException MosP例外処理が発生した場合
	 */
	public List<KdWorkDto> getKdWorkList(String year, String month) throws SQLException, IllegalAccessException,
			NoSuchFieldException, MospException {
		return getKdWorkDao().findForCondition(StringUtil.combineByHyphen(year, month));
		
	}
	
	/**
	 * 60時間超過分残業時間（平日＋所定休日）の合計取得。
	 * @param dto 対象DTO
	 * @return 対象年月の60時間超過分残業時間（平日＋所定休日）の合計
	 */
	public static int getOver60HourOverTime(KdWorkDto dto) {
		int over60Hour = 0;
		if (VariousUtil.isNotNull(dto)) {
			over60Hour = dto.getMonthlyOverTime() + dto.getMonthlyWeekHoliday();
		}
		return over60Hour;
	}
	
	/**
	 * 勤怠集計情報取得
	 * @param kCode 対象社員コード
	 * @param yearMonth 対象年月
	 * @return 勤怠集計情報
	 * @throws Exception 	例外処理が発生した場合
	 */
	public KintaiCompileDto getCompileInfo(String kCode, Date yearMonth) throws Exception {
		MKintaiDto kintaiDto = getKintaiInfo(kCode, yearMonth);
		if (VariousUtil.isNotNull(kintaiDto)) {
			return convKintaiToCompile(kintaiDto);
		} else {
			KdWorkDto kdWorkDto = getKdWorkInfo(kCode, yearMonth);
			if (VariousUtil.isNotNull(kdWorkDto)) {
				return convKdWorkToCompile(kdWorkDto);
			}
			return getCompiledInfo(kCode, part().kintai().getAttendanceList(kCode,
					part().calculate().getStartDate(yearMonth), part().calculate().getEndDate(yearMonth)), part()
				.mospcode().isAttendanceApprovalFunction());
		}
	}
	
	/* 改正労働基準法施行日対応 */

	/**
	 * 対象出勤簿・予定簿リスト勤怠集計情報（改正労働基準法施行日対応）取得
	 * @param kCode				対象社員コード
	 * @param attendanceList	対象年月出勤簿・予定簿リスト
	 * @param useApprovalFunction	勤怠承認機能フラグ
	 * @return	出勤簿・予定簿リスト勤怠集計情報
	 * @throws Exception	例外処理が発生した場合
	 */
	public KintaiCompileDto getReformCompiledInfo(String kCode, List<?> attendanceList, boolean useApprovalFunction)
			throws Exception {
		// DTOの初期化
		KintaiCompileDto compileDto = new KintaiCompileDto();
		// 変数宣言、変数の初期化
		// 勤務時間計
		int totalWork = 0;
		// 休憩時間計
		int totalInterbal = 0;
		// 遅刻時間計
		int totalLate = 0;
		// 早退時間計
		int totalLeave = 0;
		// 残業時間計
		int totalOver = 0;
		// 休出時間計
		int totalHolidayWork = 0;
		// 深夜時間計
		int totalLateNight = 0;
		// 出勤日数計
		double totalWorkDays = 0;
		// 出勤回数計
		int totalWorkNumber = 0;
		// 有休日数計
		double totalPaidHoliday = 0;
		// 特別休暇計
		double totalParticularHoliday = 0;
		// 欠勤日数計
		double totalAbsence = 0;
		// 傷病休暇計
		double totalMedicalLeave = 0;
		// 代休日数計
		double totalCompensationDay = 0;
		// 振替休暇計
		double totalTransfer = 0;
		// 其他休暇計
		double totalOther = 0;
		// 遅刻早退数
		int leaveAndLate = 0;
		// 手当
		int syokuji = 0;
		int cyoku1 = 0;
		int cyoku2 = 0;
		int cyoku3 = 0;
		int hoka1 = 0;
		int hoka2 = 0;
		int hoka3 = 0;
		int hoka4 = 0;
		int hoka5 = 0;
		// 時間単位有休数
		int unitHourHoliday = 0;
		// 休暇理由6
		double totalVacationReason6 = 0;
		// 休暇理由7
		double totalVacationReason7 = 0;
		// 休暇理由8
		double totalVacationReason8 = 0;
		// 休暇理由9
		double totalVacationReason9 = 0;
		// 平日時間外
		int totalWeekDayOverTime = 0;
		// 所定休日時間外
		int totalHolidayOverTime = 0;
		// 月60時間超過平日時間外
		int totalMonthlyWeekDayOverTime = 0;
		// 月60時間超過所定休日時間外
		int totalMonthlyHolidayOverTime = 0;
		// 時間外代替休暇取得日数
		double substituteHoliday = 0;
		// 1.00割増
		int warimasi1 = 0;
		// 入力単位
		int inputUnit = part().kintai().getInputUnitTimes();
		// 集計開始
		for (Object obj : attendanceList) {
			KintaiCommonDtoInterface dto = (KintaiCommonDtoInterface)obj;
			// 対象年月日
			Date date = DateUtil.convStringDateToDate(dto.getHizuke());
			// 労使協定情報の取得
			AgreementBaseInfo agreement = part().laborAgreement().getUserLaborAgreement(kCode, date);
			// 勤怠承認機能
			boolean compileFlag = true;
			if (useApprovalFunction && !KintaiApprovalPart.isApproved(dto)) {
				compileFlag = false;
			}
			if (compileFlag) {
				// 勤怠項目
				if (KintaiCommonPart.isAvailableWorkType(dto)) {
					// 自動計算
					if (part().kintai().isMonthlyAutoCalc()) {
						part().kintai().runCalculatedInfo(dto);
					}
					// 勤務時間
					totalWork += dto.getKinmuJi();
					// 休憩時間
					totalInterbal += dto.getKyukeiJi();
					// 遅刻時間
					totalLate += dto.getTiJikan();
					// 早退時間
					totalLeave += dto.getSoJikan();
					// 深夜時間
					totalLateNight += dto.getSnJikan();
					// 出勤日数
					if (dto.getKinmuJi() > 0) {
						totalWorkDays++;
						totalWorkNumber++;
					}
					// 遅刻早退数
					if (dto.getTiJikan() > 0 || dto.getSoJikan() > 0) {
						leaveAndLate++;
					}
					// 手当
					syokuji += dto.getSyokuji();
					cyoku1 += dto.getCyoku1();
					cyoku2 += dto.getCyoku2();
					cyoku3 += dto.getCyoku3();
					hoka1 += dto.getHoka1();
					hoka2 += dto.getHoka2();
					hoka3 += dto.getHoka3();
					hoka4 += dto.getHoka4();
					hoka5 += dto.getHoka5();
					// 月60時間時間外による代休
					if (KintaiCommonPart.isOverTimeSubHolidayHalf(dto)) {
						substituteHoliday += CommonConst.NUM_HALF_DAY;
						totalWorkDays -= CommonConst.NUM_HALF_DAY;
					}
					// 半休
					if (KintaiCommonPart.isHalfHoliday(dto)) {
						totalPaidHoliday += CommonConst.NUM_HALF_DAY;
						totalWorkDays -= CommonConst.NUM_HALF_DAY;
					}
					// 時間年休数
					unitHourHoliday += dto.getNijiKyu();
					// 1.00割増
					warimasi1 += dto.getWarimasi1();
					// 所定休日判断フラグ
					boolean standardHoliday = part().laborAgreement().isStandardHoliday(date, agreement);
					// 残業加算時間
					int overTime = dto.getZaJikan();
					// 休出時間
					int holidayWork = 0;
					// 休出判断
					if (KintaiCommonPart.isWorkOnHoliday(dto)) {
						if (VariousUtil.isNotNull(agreement)) {
							if (LaborAgreementPart.isOfficialHoliday(date, agreement)) {
								holidayWork = dto.getKsJikan();
							}
						} else {
							// 労使協定が無い場合、従来通り
							overTime = 0;
							holidayWork = dto.getKsJikan();
						}
					}
					// 休出時間
					totalHolidayWork += holidayWork;
					// 加算後残業時間
					int overAdded = overTime + totalOver;
					// 月60時間の対応
					if (totalOver > CommonConst.NUM_OVER_TIME_60_HOUR) {
						// totalOverのみで60時間超えている場合
						if (standardHoliday) {
							// 所定休日の場合
							totalMonthlyHolidayOverTime += overTime;
						} else {
							// 平日の場合
							totalMonthlyWeekDayOverTime += overTime;
						}
					} else {
						// 追加後に月60時間を超える場合
						if (overAdded > CommonConst.NUM_OVER_TIME_60_HOUR) {
							// 月60時間までの時間
							int gapTime = CommonConst.NUM_OVER_TIME_60_HOUR - totalOver;
							// 月60時間超過時間
							int overflowTime = overAdded - CommonConst.NUM_OVER_TIME_60_HOUR;
							if (standardHoliday) {
								// 所定休日の場合
								totalHolidayOverTime += gapTime;
								totalMonthlyHolidayOverTime += overflowTime;
							} else {
								// 平日の場合
								totalWeekDayOverTime += gapTime;
								totalMonthlyWeekDayOverTime += overflowTime;
							}
						} else {
							// 合計しても月60時間超えない場合
							if (standardHoliday) {
								// 所定休日の場合
								totalHolidayOverTime += overTime;
							} else {
								// 平日の場合
								totalWeekDayOverTime += overTime;
							}
						}
					}
					// 残業時間
					totalOver += overTime;
				} else {
					// 休暇項目
					if (KintaiCommonPart.isHoliday(dto)) {
						String kkRiyuu = dto.getKKRiyuu();
						if (KintaiCommonPart.isAllHoliday(dto)) {
							// 有給休暇
							totalPaidHoliday++;
						} else if (KintaiCommonPart.isParticularHoliday(kkRiyuu)) {
							// 特別休暇
							totalParticularHoliday++;
						} else if (KintaiCommonPart.isAbsence(kkRiyuu)) {
							// 欠勤日数
							totalAbsence++;
						} else if (KintaiCommonPart.isMedical(kkRiyuu)) {
							// 傷病休暇
							totalMedicalLeave++;
						} else if (KintaiCommonPart.isCompensationHoliday(dto)) {
							// 代休日数
							totalCompensationDay++;
						} else if (KintaiCommonPart.isTransfer(kkRiyuu)) {
							// 振替休暇
							totalTransfer++;
						} else if (KintaiCommonPart.isHolidayReason6(kkRiyuu)) {
							// 休憩理由6
							totalVacationReason6++;
						} else if (KintaiCommonPart.isHolidayReason7(kkRiyuu)) {
							// 休憩理由7
							totalVacationReason7++;
						} else if (KintaiCommonPart.isHolidayReason8(kkRiyuu)) {
							// 休憩理由8
							totalVacationReason8++;
						} else if (KintaiCommonPart.isHolidayReason9(kkRiyuu)) {
							// 休憩理由9
							totalVacationReason9++;
						} else if (HolidayRequestPart.isSubHoliday(dto.getKKRiyuu())) {
							// 月60時間時間外による代休の取得日数
							substituteHoliday++;
						} else {
							// 其他休暇(上記に当てはまらない場合)
							totalOther++;
						}
					}
				}
			}
		}
		// 丸め処理判断
		if (part().kintai().isRoundNumberMonthly()) {
			// 勤怠集計時に丸め処理を行う。
			// 勤務時間計
			totalWork = NumberUtil.roundIntegerNumber(totalWork, inputUnit);
			// 休憩時間計
			totalInterbal = NumberUtil.roundIntegerNumber(totalInterbal, inputUnit);
			// 遅刻時間計
			totalLate = NumberUtil.roundIntegerNumber(totalLate, inputUnit);
			// 早退時間計
			totalLeave = NumberUtil.roundIntegerNumber(totalLeave, inputUnit);
			// 残業時間計
			totalOver = NumberUtil.roundIntegerNumber(totalOver, inputUnit);
			// 休出時間計
			totalHolidayWork = NumberUtil.roundIntegerNumber(totalHolidayWork, inputUnit);
			// 1.00割増
			warimasi1 = NumberUtil.roundIntegerNumber(warimasi1, inputUnit);
			// 平日時間外
			totalWeekDayOverTime = NumberUtil.roundIntegerNumber(totalWeekDayOverTime, inputUnit);
			// 所定休日時間外
			totalHolidayOverTime = NumberUtil.roundIntegerNumber(totalHolidayOverTime, inputUnit);
			// 月60平日
			totalMonthlyWeekDayOverTime = NumberUtil.roundIntegerNumber(totalMonthlyWeekDayOverTime, inputUnit);
			// 月60所定
			totalMonthlyHolidayOverTime = NumberUtil.roundIntegerNumber(totalMonthlyHolidayOverTime, inputUnit);
		}
		// 出勤日数
		compileDto.setTotalWorkDays(totalWorkDays);
		// 出勤回数
		compileDto.setTotalWorkNumber(totalWorkNumber);
		// 勤務時間合計
		compileDto.setTotalWork(totalWork);
		// 休憩時間合計
		compileDto.setTotalInterbal(totalInterbal);
		// 有給休暇日数
		compileDto.setTotalPaidHoliday(totalPaidHoliday);
		// 特別休暇日数
		compileDto.setTotalParticularHoliday(totalParticularHoliday);
		// 欠勤休暇日数
		compileDto.setTotalAbsence(totalAbsence);
		// 傷病休暇日数
		compileDto.setTotalMedicalLeave(totalMedicalLeave);
		// 代休日数
		compileDto.setTotalCompensationDay(totalCompensationDay);
		// 振替休暇日数
		compileDto.setTotalTransfer(totalTransfer);
		// 其他休暇日数
		compileDto.setTotalOther(totalOther);
		// 遅刻早退数
		compileDto.setLeaveAndLate(leaveAndLate);
		// 遅刻時間
		compileDto.setTotalLate(totalLate);
		// 早退時間
		compileDto.setTotalLeave(totalLeave);
		// 遅刻早退時間
		compileDto.setTotalLeaveAndLate(totalLeave + totalLate);
		// 残業時間合計
		compileDto.setTotalOver(totalOver);
		// 休出時間合計
		compileDto.setTotalHolidayWork(totalHolidayWork);
		// 深夜時間合計
		compileDto.setTotalLateNight(totalLateNight);
		// 皆勤（欠勤、特別休暇、傷病、遅刻早退数の合計）
		if ((totalAbsence + totalParticularHoliday + totalMedicalLeave + leaveAndLate) == 0 && totalWorkDays != 0) {
			compileDto.setApplyAttendanceAllowance(true);
		}
		// 役職による手当支給設定
		if (!part().position().isApplyAttendanceAllowance(kCode)) {
			compileDto.setApplyAttendanceAllowance(false);
		}
		// 手当
		// 食事手当合計
		compileDto.setSyokuji(syokuji);
		// １直手当合計
		compileDto.setCyoku1(cyoku1);
		// ２直手当合計
		compileDto.setCyoku2(cyoku2);
		// ３直手当合計
		compileDto.setCyoku3(cyoku3);
		// その他手当１合計
		compileDto.setHoka1(hoka1);
		// その他手当２合計
		compileDto.setHoka2(hoka2);
		// その他手当３合計
		compileDto.setHoka3(hoka3);
		// その他手当４合計
		compileDto.setHoka4(hoka4);
		// その他手当５合計
		compileDto.setHoka5(hoka5);
		// 時間単位年休合計
		compileDto.setUnitHourHoliday(unitHourHoliday);
		// 1.00割増時間合計
		compileDto.setWarimasi1(warimasi1);
		// 休憩理由６合計
		compileDto.setTotalKkRiyuu6(totalVacationReason6);
		// 休憩理由７合計
		compileDto.setTotalKkRiyuu7(totalVacationReason7);
		// 休憩理由８合計
		compileDto.setTotalKkRiyuu8(totalVacationReason8);
		// 休憩理由９合計
		compileDto.setTotalKkRiyuu9(totalVacationReason9);
		// 平日時間外
		compileDto.setTotalWeekDayOverTime(totalWeekDayOverTime);
		// 所定休日時間外
		compileDto.setTotalWeekHolidayOverTime(totalHolidayOverTime);
		// 月60時間超過平日時間外
		compileDto.setTotalMonthlyOverTime(totalMonthlyWeekDayOverTime);
		// 月60時間超過所定休日時間外
		compileDto.setTotalMonthlyWeekHoliday(totalMonthlyHolidayOverTime);
		// 時間外時間外代替休暇日数合計
		compileDto.setTotalSubstituteHoliday(substituteHoliday);
		return compileDto;
	}
	
	/**
	 * 対象年月勤怠集計情報(新)変換
	 * @param kCode			対象社員コード
	 * @param targetMonth	対象年月日
	 * @param dto			対象年月勤怠集計情報DTO
	 * @return	勤怠集計情報
	 * @throws Exception	例外処理が発生した場合
	 */
	public KdWorkDto convCompileToKdWork(String kCode, Date targetMonth, KintaiCompileDto dto) throws Exception {
		// DTOの初期化
		KdWorkDto kdWorkDto = new KdWorkDto();
		// DTOに値をセット
		margeKdWorkAndCompile(kCode, targetMonth, part().calculate().getCalcPayment(targetMonth), kdWorkDto, dto);
		return kdWorkDto;
	}
	
	/**
	 * 対象年月勤怠集計情報(新)マージ
	 * @param kCode 	対象社員コード
	 * @param targetMonth 対象年月
	 * @param paymentDate 支給年月日
	 * @param kdWorkDto 対象DTO
	 * @param compileDto 対象年月勤怠集計情報DTO
	 */
	public static void margeKdWorkAndCompile(String kCode, Date targetMonth, Date paymentDate, KdWorkDto kdWorkDto,
			KintaiCompileDto compileDto) {
		KdWorkDto dto = kdWorkDto;
		if (VariousUtil.isNull(dto)) {
			dto = new KdWorkDto();
		}
		// 社員コード
		dto.setKCode(kCode);
		// 支給年月
		dto.setSikyuYm(DateUtil.convDateToStringYearMonthShort(targetMonth));
		// 支給年
		dto.setSNen(MospUtility.getYear(paymentDate));
		// 支給月
		dto.setSTuki(MospUtility.getMonth(paymentDate));
		// 支給日
		dto.setSHi(MospUtility.getDay(paymentDate));
		if (VariousUtil.isNotNull(compileDto)) {
			// 出勤日数
			dto.setSNissu(compileDto.getTotalWorkDays());
			// 出勤回数
			dto.setSKaisu(compileDto.getTotalWorkNumber());
			// 勤務時間合計
			dto.setKinmuJi(compileDto.getTotalWork());
			// 休憩時間合計
			dto.setKyukeiJi(compileDto.getTotalInterbal());
			// 有給休暇日数
			dto.setYukyu(compileDto.getTotalPaidHoliday());
			// 特別休暇日数
			dto.setTokukyu(compileDto.getTotalParticularHoliday());
			// 欠勤休暇日数
			dto.setKekkin(compileDto.getTotalAbsence());
			// 傷病休暇日数
			dto.setSKekkin(compileDto.getTotalMedicalLeave());
			// 代休日数
			dto.setDaikyu(compileDto.getTotalCompensationDay());
			// 振替休暇日数
			dto.setFurikae(compileDto.getTotalTransfer());
			// 休暇理由6
			dto.setKkRiyuu6(compileDto.getTotalKkRiyuu6());
			// 休暇理由7
			dto.setKkRiyuu7(compileDto.getTotalKkRiyuu7());
			// 休暇理由8
			dto.setKkRiyuu8(compileDto.getTotalKkRiyuu8());
			// 休暇理由9
			dto.setKkRiyuu9(compileDto.getTotalKkRiyuu9());
			// 其他休暇日数
			dto.setSonota(compileDto.getTotalOther());
			// 遅刻早退数
			dto.setTiSoKai(compileDto.getLeaveAndLate());
			// 遅刻早退時間合計
			dto.setTiSoJikan(compileDto.getTotalLeaveAndLate());
			// 残業時間合計
			dto.setZaJikan(compileDto.getTotalOver());
			// 休出時間合計
			dto.setKsJikan(compileDto.getTotalHolidayWork());
			// 深夜時間合計
			dto.setSnJikan(compileDto.getTotalLateNight());
			// 皆勤
			dto.setKaikin(0);
			if (compileDto.isApplyAttendanceAllowance()) {
				dto.setKaikin(1);
			}
			// 手当
			// 食事手当合計
			dto.setSyokujiKaisu(compileDto.getSyokuji());
			// １直手当合計
			dto.setCyokuKaisu1(compileDto.getCyoku1());
			// ２直手当合計
			dto.setCyokuKaisu2(compileDto.getCyoku2());
			// ３直手当合計
			dto.setCyokuKaisu3(compileDto.getCyoku3());
			// その他手当１合計
			dto.setHokaKaisu1(compileDto.getHoka1());
			// その他手当２合計
			dto.setHokaKaisu2(compileDto.getHoka2());
			// その他手当３合計
			dto.setHokaKaisu3(compileDto.getHoka3());
			// その他手当４合計
			dto.setHokaKaisu4(compileDto.getHoka4());
			// その他手当５合計
			dto.setHokaKaisu5(compileDto.getHoka5());
			// 時間単位年休合計
			dto.setHourHoliday(compileDto.getUnitHourHoliday());
			// 1.00割増
			dto.setWarimasi1(compileDto.getWarimasi1());
			// 平日時間外
			dto.setWeekDayOverTime(compileDto.getTotalWeekDayOverTime());
			// 所定休日時間外
			dto.setWeekHolidayOverTime(compileDto.getTotalWeekHolidayOverTime());
			// 月60時間超過平日時間外
			dto.setMonthlyOverTime(compileDto.getTotalMonthlyOverTime());
			// 月60時間超過所定休日時間外
			dto.setMonthlyWeekHoliday(compileDto.getTotalMonthlyWeekHoliday());
			// 時間外時間代替休暇取得日数
			dto.setSubstituteHoliday(compileDto.getTotalSubstituteHoliday());
		}
	}
	
	/**
	 * 勤怠集計情報（新）をKintaiCompileDtoへ変換
	 * @param dto 対象DTO
	 * @return 変換後勤怠集計情報
	 */
	public static KintaiCompileDto convKdWorkToCompile(KdWorkDto dto) {
		KintaiCompileDto compileDto = new KintaiCompileDto();
		if (VariousUtil.isNotNull(dto)) {
			// 出勤日数
			compileDto.setTotalWorkDays(dto.getSNissu());
			// 出勤回数
			compileDto.setTotalWorkNumber(dto.getSKaisu());
			// 勤務時間合計
			compileDto.setTotalWork(dto.getKinmuJi());
			// 休憩時間合計
			compileDto.setTotalInterbal(dto.getKyukeiJi());
			// 有給休暇日数
			compileDto.setTotalPaidHoliday(dto.getYukyu());
			// 特別休暇日数
			compileDto.setTotalParticularHoliday(dto.getTokukyu());
			// 欠勤休暇日数
			compileDto.setTotalAbsence(dto.getKekkin());
			// 傷病休暇日数
			compileDto.setTotalMedicalLeave(dto.getSKekkin());
			// 代休日数
			compileDto.setTotalCompensationDay(dto.getDaikyu());
			// 振替休暇日数
			compileDto.setTotalTransfer(dto.getFurikae());
			// 休暇理由6
			compileDto.setTotalKkRiyuu6(dto.getKkRiyuu6());
			// 休暇理由7
			compileDto.setTotalKkRiyuu7(dto.getKkRiyuu7());
			// 休暇理由8
			compileDto.setTotalKkRiyuu8(dto.getKkRiyuu8());
			// 休暇理由9
			compileDto.setTotalKkRiyuu9(dto.getKkRiyuu9());
			// 其他休暇日数
			compileDto.setTotalOther(dto.getSonota());
			// 遅刻早退数
			compileDto.setLeaveAndLate(dto.getTiSoKai());
			// 遅刻早退時間合計
			compileDto.setTotalLeaveAndLate(dto.getTiSoJikan());
			// 残業時間合計
			compileDto.setTotalOver(dto.getZaJikan());
			// 休出時間合計
			compileDto.setTotalHolidayWork(dto.getKsJikan());
			// 深夜時間合計
			compileDto.setTotalLateNight(dto.getSnJikan());
			// 皆勤
			compileDto.setApplyAttendanceAllowance(StringUtil.isFlagOn(String.valueOf(dto.getKaikin())));
			// 手当
			// 食事手当合計
			compileDto.setSyokuji(dto.getSyokujiKaisu());
			// １直手当合計
			compileDto.setCyoku1(dto.getCyokuKaisu1());
			// ２直手当合計
			compileDto.setCyoku2(dto.getCyokuKaisu2());
			// ３直手当合計
			compileDto.setCyoku3(dto.getCyokuKaisu3());
			// その他手当１合計
			compileDto.setHoka1(dto.getHokaKaisu1());
			// その他手当２合計
			compileDto.setHoka2(dto.getHokaKaisu2());
			// その他手当３合計
			compileDto.setHoka3(dto.getHokaKaisu3());
			// その他手当４合計
			compileDto.setHoka4(dto.getHokaKaisu4());
			// その他手当５合計
			compileDto.setHoka5(dto.getHokaKaisu5());
			// 時間単位年休合計
			compileDto.setUnitHourHoliday(dto.getHourHoliday());
			// 1.00割増
			compileDto.setWarimasi1(dto.getWarimasi1());
			// 平日時間外
			compileDto.setTotalWeekDayOverTime(dto.getWeekDayOverTime());
			// 所定休日時間外
			compileDto.setTotalWeekHolidayOverTime(dto.getWeekHolidayOverTime());
			// 月60時間超過平日時間外
			compileDto.setTotalMonthlyOverTime(dto.getMonthlyOverTime());
			// 月60時間超過所定休日時間外
			compileDto.setTotalMonthlyWeekHoliday(dto.getMonthlyWeekHoliday());
			// 時間外時間代替休暇取得日数
			compileDto.setTotalSubstituteHoliday(dto.getSubstituteHoliday());
		}
		return compileDto;
	}
	
	/**
	 * CSVファイル用ヘッダー配列(旧テーブル)取得
	 * @return	CSVファイル用ヘッダー配列
	 * @throws Exception 	例外処理が発生した場合
	 */
	public String[] getOldWorkCsvHeader() throws Exception {
		List<String> headerList = new LinkedList<String>();
		String[] aryColumnInfo = part().export().getTableColumnInfo(KINTAI_TABLE);
		for (String columnInfo : aryColumnInfo) {
			headerList.add(VariousUtil.getCsvSplitInfo(columnInfo, 3));
		}
		return StringUtil.listToArray(headerList);
	}
	
	/**
	 * CSVファイル用ヘッダー配列(新テーブル)取得
	 * @return	CSVファイル用ヘッダー配列
	 * @throws Exception 	例外処理が発生した場合
	 */
	public String[] getNewWorkCsvHeader() throws Exception {
		List<String> headerList = new LinkedList<String>();
		String[] aryColumnInfo = part().export().getTableColumnInfo(KINTAI_NEW_TABLE);
		for (String columnInfo : aryColumnInfo) {
			headerList.add(VariousUtil.getCsvSplitInfo(columnInfo, 3));
		}
		return StringUtil.listToArray(headerList);
	}
	
	/**
	 * @param kCode 		社員コード
	 * @param sikyuYM		支給年月
	 * @param sNen			支給年
	 * @param sTuki			支給月
	 * @param sHi			支給日
	 * @param sNissu		出勤日数
	 * @param sKaisu		出勤回数
	 * @param kinmuJi		勤務時間
	 * @param kyukeiJi		休憩時間
	 * @param yukyu			有休
	 * @param tokukyu		特別休暇
	 * @param kekkin		一般欠勤日数
	 * @param sKekkin		傷病欠勤日数
	 * @param daikyu		代替休暇
	 * @param furikae		振替休暇
	 * @param kkRiyuu6		休暇理由6
	 * @param kkRiyuu7		休暇理由7
	 * @param kkRiyuu8		休暇理由8
	 * @param kkRiyuu9		休暇理由9
	 * @param sonota		その他休暇理由
	 * @param tiSoKai		遅刻早退回数
	 * @param tiSoJikan		遅刻早退時間
	 * @param zaJikan		普通残業時間
	 * @param ksJikan		休出出勤時間
	 * @param snJikan 		深夜勤務時間
	 * @param kaikin		精皆勤手当支給
	 * @param syokujiKaisu 	食事手当支給回数
	 * @param cyokuKaisu1 	1直手当支給回数
	 * @param cyokuKaisu2 	2直手当支給回数
	 * @param cyokuKaisu3 	3直手当支給回数
	 * @param hokaKaisu1 	その他支給回数1
	 * @param hokaKaisu2 	その他支給回数2
	 * @param hokaKaisu3 	その他支給回数3
	 * @param hokaKaisu4 	その他支給回数4
	 * @param hokaKaisu5 	その他支給回数5
	 * @param sinseiGaku 	支払申請額
	 * @param warimasi1 	1.00割増
	 * @param weekDayOverTime 		平日時間外
	 * @param weekHolidayOverTime 	所定休日時間外
	 * @param monthlyOverTime 		月60時間超過平日時間外
	 * @param monthlyWeekHoliday 	月60時間超過所定休日時間外
	 * @param hourHoliday 			時間単位年休取得時間
	 * @param substituteHoliday 	時間外時間代替休暇取得日数
	 * @param amendFlag 			修正フラグ
	 * @return			新勤怠テーブルDto
	 */
	public static KdWorkDto createKdWorkDto(String kCode, String sikyuYM, int sNen, int sTuki, int sHi, double sNissu,
			int sKaisu, int kinmuJi, int kyukeiJi, double yukyu, double tokukyu, double kekkin, double sKekkin,
			double daikyu, double furikae, double kkRiyuu6, double kkRiyuu7, double kkRiyuu8, double kkRiyuu9,
			double sonota, int tiSoKai, int tiSoJikan, int zaJikan, int ksJikan, int snJikan, int kaikin,
			int syokujiKaisu, int cyokuKaisu1, int cyokuKaisu2, int cyokuKaisu3, int hokaKaisu1, int hokaKaisu2,
			int hokaKaisu3, int hokaKaisu4, int hokaKaisu5, int sinseiGaku, int warimasi1, int weekDayOverTime,
			int weekHolidayOverTime, int monthlyOverTime, int monthlyWeekHoliday, int hourHoliday,
			double substituteHoliday, int amendFlag) {
		KdWorkDto dto = new KdWorkDto();
		dto.setKCode(kCode);
		dto.setSikyuYm(sikyuYM);
		dto.setSNen(sNen);
		dto.setSTuki(sTuki);
		dto.setSHi(sHi);
		dto.setSNissu(sNissu);
		dto.setSKaisu(sKaisu);
		dto.setKinmuJi(kinmuJi);
		dto.setKyukeiJi(kyukeiJi);
		dto.setYukyu(yukyu);
		dto.setTokukyu(tokukyu);
		dto.setKekkin(kekkin);
		dto.setSKekkin(sKekkin);
		dto.setDaikyu(daikyu);
		dto.setFurikae(furikae);
		dto.setKkRiyuu6(kkRiyuu6);
		dto.setKkRiyuu7(kkRiyuu7);
		dto.setKkRiyuu8(kkRiyuu8);
		dto.setKkRiyuu9(kkRiyuu9);
		dto.setSonota(sonota);
		dto.setTiSoKai(tiSoKai);
		dto.setTiSoJikan(tiSoJikan);
		dto.setZaJikan(zaJikan);
		dto.setKsJikan(ksJikan);
		dto.setKaikin(kaikin);
		dto.setSyokujiKaisu(syokujiKaisu);
		dto.setCyokuKaisu1(cyokuKaisu1);
		dto.setCyokuKaisu2(cyokuKaisu2);
		dto.setCyokuKaisu3(cyokuKaisu3);
		dto.setHokaKaisu1(hokaKaisu1);
		dto.setHokaKaisu2(hokaKaisu2);
		dto.setHokaKaisu3(hokaKaisu3);
		dto.setHokaKaisu4(hokaKaisu4);
		dto.setHokaKaisu5(hokaKaisu5);
		return dto;
	}
	
	/**
	 * 修正フラグコード取得
	 * @param kCode 対象社員コード
	 * @param year 対象年
	 * @param month 対象月
	 * @return 修正フラグコード
	 * @throws Exception 例外処理が発生した場合
	 */
	public String getAmendFlagCode(String kCode, int year, int month) throws Exception {
		if (MosPCodePart.afterLegalReformDate(DateUtil.getYearMonth(year, month))) {
			KdWorkDto kdWorkDto = getKdWorkInfo(kCode, year, month);
			if (VariousUtil.isNotNull(kdWorkDto)) {
				if (kdWorkDto.getAmendFlag() == MospConst.DELETE_FLAG_ON) {
					return String.valueOf(MospConst.DELETE_FLAG_ON);
				}
				return String.valueOf(MospConst.DELETE_FLAG_OFF);
			}
		} else {
			MKintaiDto kintaiDto = getKintaiInfo(kCode, year, month);
			if (VariousUtil.isNotNull(kintaiDto)) {
				if (kintaiDto.getInsertDate().compareTo(kintaiDto.getUpdateDate()) != 0) {
					return String.valueOf(MospConst.DELETE_FLAG_ON);
				}
				return String.valueOf(MospConst.DELETE_FLAG_OFF);
			}
			
		}
		return "";
	}
	
	/**
	 * 修正フラグコード取得
	 * @param kCode 対象社員コード
	 * @param year 対象年
	 * @param month 対象月
	 * @return 修正フラグコード
	 * @throws Exception 例外処理が発生した場合
	 */
	public String getAmendFlagCode(String kCode, String year, String month) throws Exception {
		return getAmendFlagCode(kCode, NumberUtil.getIntParam(year), NumberUtil.getIntParam(month));
	}
	
	/**
	 * 修正フラグ名称
	 * @param code 修正フラグコード
	 * @return  修正フラグ名称
	 * <p>
	 * codeが空欄の場合「{@link CommonConst#NAM_REMAIN_COMPILE}」、<br>
	 * codeが「0」の場合「{@link CommonConst#NAM_COMPILE_COMPLETE}」、<br>
	 * codeが「1」の場合「{@link CommonConst#NAM_COMPILE_AMEND}」。
	 * </p>
	 */
	public static String getAmendFlagName(String code) {
		if (StringUtil.isNotNull(code)) {
			if (String.valueOf(MospConst.DELETE_FLAG_OFF).equals(code)) {
				return CommonConst.NAM_COMPILE_COMPLETE;
			}
			if (String.valueOf(MospConst.DELETE_FLAG_ON).equals(code)) {
				return CommonConst.NAM_COMPILE_AMEND;
			}
		}
		return CommonConst.NAM_REMAIN_COMPILE;
	}
	
}
