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

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.sql.SQLException;

import org.apache.commons.csv.CSVParser;
import org.apache.commons.fileupload.FileItem;

import jp.mosp.common.CommonConst;
import jp.mosp.common.CommonUtility;
import jp.mosp.common.DataSourceUtility;
import jp.mosp.common.ExportInfoUtility;
import jp.mosp.common.MosPMenuConst;
import jp.mosp.common.common.BaseAction;
import jp.mosp.common.common.BaseDto;
import jp.mosp.common.common.LogUtility;
import jp.mosp.common.common.MospConst;
import jp.mosp.common.common.MospException;
import jp.mosp.common.common.MospUtility;
import jp.mosp.common.dao.CmAuthorityDao;
import jp.mosp.common.dao.CmCodeDao;
import jp.mosp.common.dao.CmComponentDao;
import jp.mosp.common.dao.MosPConfDao;
import jp.mosp.common.dao.MosPUserDao;
import jp.mosp.common.dto.CmAspUserDto;
import jp.mosp.common.dto.CmAuthorityDto;
import jp.mosp.common.dto.CmCodeDto;
import jp.mosp.common.dto.CmComponentDto;
import jp.mosp.common.dto.MosPConfDto;
import jp.mosp.common.dto.MosPUserDto;
import jp.mosp.common.vo.ExclusiveVo;
import jp.mosp.common.vo.MosPVo;

import jp.mosp.human.dao.MKihonDao;
import jp.mosp.human.dto.MKihonDto;

import jp.mosp.payroll.dao.MKintaiKeisanDao;
import jp.mosp.payroll.dto.MKintaiKeisanDto;

import jp.mosp.system.dao.MCodeDao;
import jp.mosp.system.dao.MExportColumnDao;
import jp.mosp.system.dao.MKaisyaDao;
import jp.mosp.system.dao.MSyozokuDao;
import jp.mosp.system.dao.MWorkTypeDao;
import jp.mosp.system.dao.MYakusyokuDao;

import jp.mosp.system.dto.MCodeDto;
import jp.mosp.system.dto.MExportColumnDto;
import jp.mosp.system.dto.MKaisyaDto;
import jp.mosp.system.dto.MSyozokuDto;
import jp.mosp.system.dto.MWorkTypeDto;
import jp.mosp.system.dto.MYakusyokuDto;

public abstract class MosPAction extends BaseAction {

	// 排他関連フィールド
	private boolean needExclusive;
	private List    listExclusive;

	// フィールド
	protected MosPUserDto mospUser;
	protected MKihonDto mKihon;

	protected BufferedReader br;

	protected CommonUtility util;

	/**
	 * コンストラクタ
	 */
	public MosPAction() {
		super();
		setCheckAuth(false);
		setNeedExclusive(false);
		util = new CommonUtility();
	}

	/**
	 * アクション後処理
	 * @throws SQLException
	 */
	@Override
	protected void afterAction() throws SQLException {
		super.afterAction();
		if (!needExclusive) {
			if (user != null) {
				deleteExclusive(user.getUserId());
			}
		}
	}

	/**
	 * CmAspUserDtoの生成
	 */
	protected void createAspUser() {
		aspUser = new CmAspUserDto();
		aspUser.setAspUserId(cfg.getProperty(MospConst.PPT_ASP_ASPUSER));
		aspUser.setAspName(cfg.getProperty(MospConst.PPT_ASP_ASPNAME));
		aspUser.setDbDriver(cfg.getProperty(MospConst.PPT_ASP_DBDRIVER));
		aspUser.setDbUrl(cfg.getProperty(MospConst.PPT_ASP_DBURL));
		aspUser.setDbUser(cfg.getProperty(MospConst.PPT_ASP_DBUSER));
		aspUser.setDbPass(cfg.getProperty(MospConst.PPT_ASP_DBPASS));
	}

	/**
	 * ロゴファイル利用可否判断
	 */
	protected void setUseLogo() {
		boolean useLogoFlag = false;
		String useLogo = cfg.getProperty(CommonConst.PPT_USE_LOGO);
		if (useLogo != null 
				&& useLogo.length() != 0 
				&& Boolean.parseBoolean(useLogo) 
				&& new File(
						cfg.getProperty(MospConst.PPT_APP_DOCBASE) + CommonConst.FILE_LOGO
				) != null
		) {
			useLogoFlag = true;
		}
		cfg.setProperty(CommonConst.PPT_USE_LOGO, String.valueOf(useLogoFlag));
	}

	/**
	 * 初期VOインスタンス取得
	 * @return	初期VO
	 * <p>
	 * MosPの機能を継承して作る場合、このメソッドをオーバーライドすることで、
	 * MosPVoを継承したそれぞれのVOをインスタンス化したものを取得する。
	 * </p>
	 */
	protected MosPVo getInitVo() {
		return null;
	}

	/**
	 * 削除フラグリスト取得
	 * @return 削除フラグリスト
	 */
	protected String[][] getDeleteArray() {
		String[][] array = new String[2][2];
		array[0][0] = String.valueOf(MospConst.DELETE_FLAG_OFF);
		array[0][1] = MospConst.DELETE_FLAG_OFF_NAME;
		array[1][0] = String.valueOf(MospConst.DELETE_FLAG_ON);
		array[1][1] = MospConst.DELETE_FLAG_ON_NAME;
		return array;
	}

	/**
	 * 適用フラグリスト取得
	 * @return 削除フラグリスト
	 */
	protected String[][] getApplicableFlagArray() {
		String[][] array = new String[2][2];
		array[0][0] = String.valueOf(CommonConst.APPLICABLE_FLAG_OFF);
		array[0][1] = CommonConst.NAM_APPLICABLE_FLAG_OFF;
		array[1][0] = String.valueOf(CommonConst.APPLICABLE_FLAG_ON);
		array[1][1] = CommonConst.NAM_APPLICABLE_FLAG_ON;
		return array;
	}

	/**
	 * 設定リスト取得(MOSP_CONF)
	 * @param confId 設定区分
	 * @return 設定リスト
	 * @throws Exception
	 */
	protected String[][] getConfArray(String confId) throws Exception {
		// DAOの宣言
		MosPConfDao dao = new MosPConfDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// データの取得
		List<MosPConfDto> list = dao.findForCondition(confId);
		// データの整形
		String[][] array = new String[list.size()][2];
		for (int i = 0; i < list.size(); i++) {
			MosPConfDto dto = list.get(i);
			array[i][0] = dto.getConfCode();
			array[i][1] = dto.getConfValue();
		}
		return array;
	}

	/**
	 * 設定値取得(MOSP_CONF)
	 * @param confId   設定区分
	 * @param confCode 設定コード
	 * @return 設定値
	 * @throws Exception
	 */
	protected String getConfValue(String confId, String confCode) throws Exception {
		// DAOの宣言
		MosPConfDao dao = new MosPConfDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// データの取得
		MosPConfDto dto = dao.findForKey(confId, confCode);
		if (dto == null) {
			return "";
		}
		return dto.getConfValue();
	}

	/**
	 * 設定リスト取得(MOSP_CONF)
	 * @param confId 設定区分
	 * @return 設定リスト
	 * @throws NoSuchFieldException 
	 * @throws IllegalAccessException 
	 * @throws SQLException 
	 */
	protected List<MosPConfDto> getConfList(
			String confId
	) throws SQLException, IllegalAccessException, NoSuchFieldException  {
		// DAOの宣言
		MosPConfDao dao = new MosPConfDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// データの取得
		return dao.findForCondition(confId);
	}

	/**
	 * ユーザー情報取得
	 * @param userId 対象ユーザーID
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected void getInfo(
			String userId
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		mospUser 	= getUserInfo(userId);
		mKihon 		= getBasisInfo(mospUser.getKCode());
	}

	/**
	 * 人事基本情報取得(M_KIHON)
	 * @param kCode 情報取得対象社員コード
	 * @return 人事基本情報(UmBasisDto)
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected MKihonDto getBasisInfo(
			String kCode
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MKihonDao dao = new MKihonDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		return dao.findForKey(kCode);
	}

	/**
	 * 社員氏名取得(M_KIHON)
	 * @param kCode 情報取得対象社員コード
	 * @return 社員氏名
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String getKName(
			String kCode
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		MKihonDto dto = getBasisInfo(kCode);
		if (dto == null) {
			return kCode;
		}
		return dto.getSimei();
	}

	/**
	 * 社員コード取得(M_KIHON)(現所属)
	 * @param sectionCode 検索所属コード
	 * @return 社員コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[] getBasisArray(
			String sectionCode
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MKihonDao dao = new MKihonDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MKihonDto> listKihon = dao.findForSection(
				sectionCode,
				util.convDateToInteger(util.getSystemDate())
		);
		// 配列の作成
		String[] aryKihon = new String[listKihon.size()];
		for (int i = 0; i < listKihon.size(); i++) {
			aryKihon[i] = listKihon.get(i).getKCode();
		}
		return aryKihon;
	}

	/**
	 * 社員コード取得(M_KIHON)(指定年月日所属)
	 * @param sectionCode 検索所属コード
	 * @param targetMonth 選択年月日
	 * @return 社員コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[] getBasisArray(
			String sectionCode,
			Date targetMonth
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MKihonDao dao = new MKihonDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MKihonDto> listKihon = dao.findForSection(
				sectionCode,
				util.convDateToInteger(targetMonth)
		);
		// 配列の作成
		String[] aryKihon = new String[listKihon.size()];
		for (int i = 0; i < listKihon.size(); i++) {
			aryKihon[i] = listKihon.get(i).getKCode();
		}
		return aryKihon;
	}

	/**
	 * 社員コード取得(M_KIHON)
	 * @return 社員コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getBasisArrayAll() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MKihonDao dao = new MKihonDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MKihonDto> listKihon = dao.findAll();
		// 配列の作成
		String[][] aryKihon = new String[listKihon.size()][2];
		for (int i = 0; i < listKihon.size(); i++) {
			aryKihon[i][0] = listKihon.get(i).getKCode();
			aryKihon[i][1] = listKihon.get(i).getSimei();
		}
		return aryKihon;
	}

	/**
	 * 社員コード取得(M_KIHON)
	 * @return 社員コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getBasisArrayForApproval() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MKihonDao dao = new MKihonDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MKihonDto> listKihon = dao.findForAuth(
				CommonConst.AUTHORITY_MANAGER,
				CommonConst.AUTHORITY_SENIORS,
				util.convDateToInteger(util.getSystemDate())
		);
		// 配列の作成
		String[][] aryKihon = new String[listKihon.size()][2];
		for (int i = 0; i < listKihon.size(); i++) {
			aryKihon[i][0] = listKihon.get(i).getKCode();
			aryKihon[i][1] = listKihon.get(i).getSimei();
		}
		return aryKihon;
	}

	/**
	 * 社員コード、所属コード取得(M_KIHON)
	 * @return 社員コードリスト
	 * @throws Exception 
	 */
	protected String[][] getBasisArrayAllWithSectionCode() throws Exception {
		// DAOの準備
		MKihonDao dao = new MKihonDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MKihonDto> listKihon = dao.findAll();
		// 配列の作成
		String[][] aryKihon = new String[listKihon.size()][2];
		for (int i = 0; i < listKihon.size(); i++) {
			aryKihon[i][0] = listKihon.get(i).getKCode();
			aryKihon[i][1] = getBelongSectionCode(listKihon.get(i).getKCode());
		}
		return aryKihon;
	}

	/**
	 * 選択社員所属社員コード一覧取得(M_KIHON)
	 * @param kcode		対象社員コード
	 * @return	社員コードリスト
	 * @throws Exception
	 */
	protected String[][] getBasisArrayForBelongSection(String kcode) throws Exception {
		// 検索
		MKihonDao mKihonDao = new MKihonDao();
		mKihonDao.initDao(cfg, cmd, aspUser, user, conn);
		List<MKihonDto> listMKihon = mKihonDao.findForCondition(
				getBelongSectionCode(kcode),
				mKihon.getJCode(),
				mKihon.getKCode(),
				mospUser.getDataLevel(),
				util.convDateToInteger(util.getSystemDate())
		);
		String[][] aryBasis = new String[listMKihon.size()][2];
		for (int i = 0; i < aryBasis.length; i++) {
			aryBasis[i][0] = listMKihon.get(i).getKCode();
			aryBasis[i][1] = listMKihon.get(i).getSimei();
		}
		return aryBasis;
	}

	/**
	 * 勤続年数（月数）取得
	 * @param kCode
	 * @return y.m<br>月はそのまま
	 * 				[例] 26月→2.02年
	 * @throws SQLException
	 * @throws IllegalAccessException
	 * @throws NoSuchFieldException
	 */
	protected double getYearsOfService(
			String kCode
	) throws SQLException, IllegalAccessException, NoSuchFieldException {
		MKihonDto dto = getBasisInfo(kCode);
		int difference = 0;
		if (dto != null) {
			difference = util.getMonthRemainder(
					util.getSystemDate(),
					util.convIntegerDateToDate(dto.getNyDate())
			);			
		}
		double yearsOfService = difference /12 + difference %12 /100;
		return yearsOfService;
	}

	/**
	 * 在職社員情報取得
	 * @param kCode		対象社員コード
	 * @return			在職社員情報
	 * @throws Exception
	 */
	protected MKihonDto getAvailableUserInfo(String kCode) throws Exception {
		MKihonDto dto = getBasisInfo(kCode);
		if (chkExistDto(dto)) {
			// 退職区分が退職の場合。
			if (isRetiredEmployee(kCode)) {
				return null;
			}
			// 退職区分が休職の場合。
			if (dto.getKnKubun().equals(String.valueOf(CommonConst.RETIREMENT_FLAG_LEAVE))) {
				return null;
			}
		}
		return dto;
	}

	/**
	 * 退職判断
	 * @param kCode		対象社員コード
	 * @return
	 * <p>
	 * 退職の場合。true、そうでない場合false。
	 * </p>
	 * @throws Exception
	 */
	protected boolean isRetiredEmployee (String kCode) throws Exception {
		MKihonDto dto = getBasisInfo(kCode);
		if (chkExistDto(dto)) {
			// 退職区分が退職且つ、退職日付が本日より前の場合。
			if (dto.getKnKubun().equals(String.valueOf(CommonConst.RETIREMENT_FLAG_ON))
					&& (dto.getTsDate() > 0
							&& dto.getTsDate() < util.convDateToInteger(util.getSystemDate())
					)
			) {
				return true;
			}
		} else {
			return true;
		}
		return false;
	}

	/**
	 * コードリスト取得(CM_CODE)
	 * @param tId コード区分
	 * @return コードリスト
	 * @throws NoSuchFieldException 
	 * @throws IllegalAccessException 
	 * @throws SQLException 
	 */
	@Override
	protected String[][] getCodeArray(String tId) throws SQLException, IllegalAccessException, NoSuchFieldException {
		// DAOの宣言
		CmCodeDao dao = new CmCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// データの取得
		List<CmCodeDto> list = dao.findForCondition(tId);
		// データの整形
		String[][] array = new String[list.size()][2];
		for (int i = 0; i < list.size(); i++) {
			CmCodeDto dto = list.get(i);
			array[i][0] = dto.getTCode();
			array[i][1] = dto.getTName();
		}
		return array;
	}

	/**
	 * コード区分取得(CM_CODE)
	 * @return コード区分リスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getCodeArray() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		CmCodeDao dao = new CmCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// コード区分の取得(distinctデータ)
		List<CmCodeDto> list = dao.findAllTId();     
		String[][] aryCode = new String[list.size()][2];
		// Stingの配列に格納
		for (int i = 0; i < list.size(); i++) {
			String tId = list.get(i).getTId();
			aryCode[i][0] = tId;
			aryCode[i][1] = getCodeTypeName(tId);
		}
		return aryCode;
	}

	/**
	 * コード区分名称取得(CM_CODE)
	 * @param	tId コード区分
	 * @return	tId コード区分名称
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String getCodeTypeName(String tId) {
		if (tId.equals(CommonConst.TID_AUTHORITY)) {
			return CommonConst.TNM_AUTHORITY;
		} else {
			return tId;
		}
	}

	/**
	 * 権限コードリスト取得(CM_AUTHORITY)
	 * @return コードリスト
	 * @throws NoSuchFieldException 
	 * @throws IllegalAccessException 
	 * @throws SQLException 
	 */
	protected String[][] getArrangeAuthArray() throws SQLException, IllegalAccessException, NoSuchFieldException{
		// DAOの宣言
		CmAuthorityDao dao = new CmAuthorityDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// データの取得
		List<CmAuthorityDto> list = dao.findForAvailable();
		// データの整形
		String[][] array = new String[list.size()][2];
		for (int i = 0; i < list.size(); i++) {
			CmAuthorityDto dto = list.get(i);
			array[i][0] = dto.getAuthCode();
			array[i][1] = dto.getAuthName();
		}
		return array;
	}

	/**
	 * 全権限コードリスト取得(CM_AUTHORITY)
	 * @return コードリスト
	 * @throws SQLException
	 * @throws IllegalAccessException
	 * @throws NoSuchFieldException
	 */
	protected String[][] getArrangeAuthArrayAll() throws SQLException, IllegalAccessException, NoSuchFieldException {
		// DAOの宣言
		CmAuthorityDao dao = new CmAuthorityDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// データの取得
		List<CmAuthorityDto> list = dao.findAll();
		// データの整形
		String[][] array = new String[list.size()][2];
		for (int i = 0; i < list.size(); i++) {
			CmAuthorityDto dto = list.get(i);
			array[i][0] = dto.getAuthCode();
			array[i][1] = dto.getAuthName();
		}
		return array;
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード区分リスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getMosPCodeArray() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MCodeDao dao = new MCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// コード区分の取得(distinctデータ)
		List<MCodeDto> list = dao.findAllTId();     
		String[][] aryCode = new String[list.size()][2];
		// Stingの配列に格納
		for (int i = 0; i < list.size(); i++) {
			String tId = list.get(i).getTId();
			aryCode[i][0] = tId;
			aryCode[i][1] = tId;
		}
		return aryCode;
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * @param tid コードID
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getMosPCodeArray(String tid) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MCodeDao dao = new MCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// コードの取得
		List<MCodeDto> list = dao.findForCondition(tid);     
		String[][] aryCode = new String[list.size()][2];
		// Stingの配列に格納
		for (int i = 0; i < list.size(); i++) {
			aryCode[i][0] = list.get(i).getTCode();
			aryCode[i][1] = list.get(i).getTName();
		}
		return aryCode;
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * 			[2]tchange
	 * @param tid コードID
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getMosPCodeArray(String tid, String tcode) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MCodeDao dao = new MCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// コードの取得
		List<MCodeDto> list = dao.findForCondition(tid, tcode);     
		String[][] aryCode = new String[list.size()][3];
		// Stingの配列に格納
		for (int i = 0; i < list.size(); i++) {
			aryCode[i][0] = list.get(i).getTCode();
			aryCode[i][1] = list.get(i).getTName();
			aryCode[i][2] = list.get(i).getTChange();
		}
		return aryCode;
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * 			[2]tchange
	 * @param tid コードID
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[] getMosPCode(String tid, String tcode) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MCodeDao dao = new MCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// コードの取得
		MCodeDto dto = dao.findForKey(tid, tcode);     
		String[] aryCode = new String[3];
		// Stingの配列に格納
		if (dto != null) {
			for (int i = 0; i < 3; i++) {
				aryCode[0] = dto.getTCode();
				aryCode[1] = dto.getTName();
				aryCode[2] = dto.getTChange();
			}
		}
		return aryCode;
	}

	/**
	 * 理由区分取得(M_CODE)
	 * @param tid コードID
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getReasonCodeArray(String tid) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MCodeDao dao = new MCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// コードの取得
		List<MCodeDto> list = dao.findForReason(tid);     
		String[][] aryCode = new String[list.size()][2];
		// Stingの配列に格納
		for (int i = 0; i < list.size(); i++) {
			aryCode[i][0] = list.get(i).getTCode();
			aryCode[i][1] = list.get(i).getTName();
		}
		return aryCode;
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * 			[2]tchange
	 * @param tid コードID
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[] getMosPCode(String tid) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MCodeDao dao = new MCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// コードの取得
		MCodeDto dto = dao.findForDto(tid);     
		String[] aryCode = new String[3];
		// Stingの配列に格納
		for (int i = 0; i < 3; i++) {
			aryCode[0] = dto.getTCode();
			aryCode[1] = dto.getTName();
			aryCode[2] = dto.getTChange();
		}
		return aryCode;
	}

	/**
	 * ユーザー情報取得(MOSP_USER)
	 * @param userId 情報取得対象ユーザーID
	 * @return ユーザー情報(UmUserDto)
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected MosPUserDto getUserInfo(
			String userId
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MosPUserDao dao = new MosPUserDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		return dao.findForKey(userId);
	}

	/**
	 * ユーザー情報取得(MOSP_USER)
	 * @param kcode		情報取得対象社員コード
	 * @return ユーザー情報(UmUserDto)
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected MosPUserDto getUserInfoForKCode(String kcode) throws SQLException, NoSuchFieldException, IllegalAccessException {
		MosPUserDao dao = new MosPUserDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		return dao.findForKCode(kcode);
	}

	/**
	 * MANAGER権限確認
	 * @return TRAINER権限有無(true：権限有、false：権限無)
	 * @throws Exception
	 */
	protected boolean hasManagerAuth() throws Exception {
		// MANAGER権限確認
		boolean hasAuth = false;
		if (mospUser == null) {
			getInfo(user.getUserId());
		}
		String userAuth = mospUser.getAuthority();
		CmAuthorityDao dao = new CmAuthorityDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		CmAuthorityDto dto = dao.findForKey(userAuth);
		// デフォルトコードの設定
		if (dto == null 
				&& (userAuth.equals(CommonConst.AUTHORITY_MANAGER) 
						|| userAuth.equals(CommonConst.AUTHORITY_SENIORS)
				)
		) {
			dto = new CmAuthorityDto();
			dto.setManager(CommonConst.CONF_ID_MANAGER);	
		}
		if (dto != null && !dto.getManager().equals("")) {
			hasAuth = true;
		}		
		return hasAuth;
	}

	/**
	 * MANAGER権限確認
	 * @throws Exception
	 */
	protected void confirmManagerAuth() throws Exception {
		if (!hasManagerAuth()) {
			throw new MospException(MospConst.EX_AUTHORITY);
		}
	}

	/**
	 * PAYROLL権限確認
	 * @return PAYROLL権限有無(true：権限有、false：権限無)
	 * @throws Exception
	 */
	protected boolean hasPayrollAuth() throws Exception {
		// PAYROLL権限確認
		boolean hasAuth = false;
		if (mospUser == null) {
			getInfo(user.getUserId());
		}
		String userAuth = mospUser.getAuthority();
		CmAuthorityDao dao = new CmAuthorityDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		CmAuthorityDto dto = dao.findForKey(userAuth);
		// デフォルトコードの設定
		if (dto == null
				&& (userAuth.equals(CommonConst.AUTHORITY_PAYROLL) 
						|| userAuth.equals(CommonConst.AUTHORITY_SENIORS)
						|| userAuth.equals(CommonConst.AUTHORITY_CALCULATE)
				)
		) {
			dto = new CmAuthorityDto();
			dto.setPayroll(CommonConst.CONF_ID_PAYROLL);	
		}
		if (dto != null && !dto.getPayroll().equals("")) {
			hasAuth = true;
		}		
		return hasAuth;
	}

	/**
	 * PAYROLL権限確認
	 * @throws Exception
	 */
	protected void confirmPayrollAuth() throws Exception {
		if (!hasPayrollAuth()) {
			throw new MospException(MospConst.EX_AUTHORITY);
		}
	}

	/**
	 * HUMAN権限確認
	 * @return PAYROLL権限有無(true：権限有、false：権限無)
	 * @throws Exception
	 */
	protected boolean hasHumanAuth() throws Exception {
		// HUMAN権限確認
		boolean hasAuth = false;
		if (mospUser == null) {
			getInfo(user.getUserId());
		}
		String userAuth = mospUser.getAuthority();
		CmAuthorityDao dao = new CmAuthorityDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		CmAuthorityDto dto = dao.findForKey(userAuth);
		// デフォルトコードの設定
		if (dto == null 
				&& (userAuth.equals(CommonConst.AUTHORITY_HUMAN) 
						|| userAuth.equals(CommonConst.AUTHORITY_SENIORS)
				)
		) {
			dto = new CmAuthorityDto();
			dto.setHuman(CommonConst.CONF_ID_HUMAN);
		}
		if (dto != null && !dto.getHuman().equals("")) {
			hasAuth = true;
		}
		return hasAuth;
	}

	/**
	 * HUMAN権限確認
	 * @throws Exception
	 */
	protected void confirmHumanAuth() throws Exception {
		if (!hasHumanAuth()) {
			throw new MospException(MospConst.EX_AUTHORITY);
		}
	}

	/**
	 * CALCULATE権限確認
	 * @return CALCULATE権限有無(true：権限有、false：権限無)
	 * @throws Exception
	 */
	protected boolean hasCalculateAuth() throws Exception {
		// CALCULATE権限確認
		boolean hasAuth = false;
		if (mospUser == null) {
			getInfo(user.getUserId());
		}
		String userAuth = mospUser.getAuthority();
		CmAuthorityDao cmAuthorityDao = new CmAuthorityDao();
		cmAuthorityDao.initDao(cfg, cmd, aspUser, user, conn);
		CmComponentDao cmComponentDao = new CmComponentDao();
		cmComponentDao.initDao(cfg, cmd, aspUser, user, conn);
		CmComponentDto cmComponentDto = null;
		CmAuthorityDto cmAuthorityDto = cmAuthorityDao.findForKey(userAuth);
		if (cmAuthorityDto != null) {
			cmComponentDto = cmComponentDao.findForDto(cmAuthorityDto.getPayroll(), CommonConst.CONF_ID_PAYROLL);
		}
		if (userAuth.equals(CommonConst.AUTHORITY_CALCULATE)) {
			// デフォルトコードの設定
			if (cmAuthorityDto == null) {
				cmAuthorityDto = new CmAuthorityDto();
				cmAuthorityDto.setPayroll(CommonConst.CONF_ID_CALCULATE);	
				cmComponentDto = cmComponentDao.findForDto(cmAuthorityDto.getPayroll(), CommonConst.CONF_ID_PAYROLL);
			}
			// デフォルトコードの設定
			if (cmComponentDto == null) {
				cmComponentDto = new CmComponentDto();
				cmComponentDto.setComponent(MosPMenuConst.getCalcCmdArray()[1]);	
			}			
		}
		if (cmComponentDto != null) {
			String [] aryCmd = util.divideByComma(cmComponentDto.getComponent());
			for (int i = 0; i < aryCmd.length ; i++) {
				if (aryCmd[i].equals(MosPMenuConst.getCalcCmdArray()[1])
						|| aryCmd[i].equals(MosPMenuConst.getCalcCmdArray()[5])
						|| aryCmd[i].equals(MosPMenuConst.getPayrollCmdArray()[7][0])
						|| aryCmd[i].equals(MosPMenuConst.getPayrollCmdArray()[8][0])		
				) {
					hasAuth = true;
					break;
				}			
			}
		}
		return hasAuth;
	}

	/**
	 * CALCULATE権限確認
	 * @throws Exception
	 */
	protected void confirmCalculateAuth() throws Exception {
		if (!hasCalculateAuth()) {
			throw new MospException(MospConst.EX_AUTHORITY);
		}
	}

	/**
	 * SYSTEM権限確認
	 * @return SYSTEM権限有無(true：権限有、false：権限無)
	 * @throws IllegalAccessException 
	 * @throws NoSuchFieldException 
	 * @throws SQLException 
	 */
	protected boolean hasSystemAuth() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// ADMIN権限確認
		if (mospUser == null) {
			getInfo(user.getUserId());
		}
		return mospUser.getAuthority().equals(CommonConst.AUTH_SYSTEM);
	}

	/**
	 * SYSTEM権限確認
	 * @throws MospException
	 * @throws IllegalAccessException 
	 * @throws NoSuchFieldException 
	 * @throws SQLException 
	 */
	protected void confirmSystemAuth() throws MospException, SQLException, NoSuchFieldException, IllegalAccessException {
		if (!hasSystemAuth()) {
			throw new MospException(MospConst.EX_AUTHORITY);
		}
	}

	/**
	 * 事業所情報取得(M_KAISYA)
	 * @param jCode 情報取得対象事業所コード
	 * @return 事業所情報(MKaisyaDto)
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected MKaisyaDto getOfficeInfo(
			String jCode
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MKaisyaDao dao = new MKaisyaDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		return dao.findForKey(jCode);
	}

	/**
	 * 事業所コード取得(M_KAISYA)
	 * @return 事業所コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getOfficeArrayAll() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MKaisyaDao dao = new MKaisyaDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MKaisyaDto> listOffice = dao.findAll();
		// 配列の作成
		String[][] aryOffice = new String[listOffice.size()][2];
		for (int i = 0; i < listOffice.size(); i++) {
			aryOffice[i][0] = listOffice.get(i).getId();
			aryOffice[i][1] = listOffice.get(i).getKaiMei();
		}
		return aryOffice;
	}

	/**
	 * 事業所コード取得(利用可能所属のみ)(M_KAISYA)
	 * @return 事業所コードリスト
	 * @throws Exception
	 */
	protected String[][] getOfficeArray() throws Exception {
		if (mospUser == null) {
			getInfo(user.getUserId());
		}
		// DAOの準備
		MKaisyaDao dao = new MKaisyaDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MKaisyaDto> listOffice;
		if (hasPayrollAuth()) {
			listOffice = dao.findAll();
		} else {
			listOffice = dao.findForCondition(mKihon.getJCode());
		}
		// 配列の作成
		String[][] aryOffice = new String[listOffice.size()][2];
		for (int i = 0; i < listOffice.size(); i++) {
			aryOffice[i][0] = listOffice.get(i).getId();
			aryOffice[i][1] = listOffice.get(i).getKaiMei();
		}
		return aryOffice;
	}

	/**
	 * 事業所コード取得（所属のみ）(M_KAISYA)
	 * @param kCode 取得対象社員コード
	 * @return 事業所コード
	 * @throws Exception
	 */
	protected String getBelongOfficeCode(String kCode) throws Exception {
		String strJCode = "";
		// 人事基本情報取得
		MKihonDto mKihonDto = getBasisInfo(kCode);
		if (chkExistDto(mKihonDto)) {
			strJCode = mKihonDto.getJCode();
			// 事業所情報取得
			if (strJCode != null) {
				MKaisyaDao dao = new MKaisyaDao();
				dao.initDao(cfg, cmd, aspUser, user, conn);
				MKaisyaDto dto = dao.findForKey(strJCode);
				if (chkExistDto(dto)) {
					strJCode = dto.getId();
				} else {
					strJCode = "";
				}
			}
		}
		return strJCode;
	}

	/**
	 * 所属情報取得(M_SYOZOKU)
	 * @param sCode 情報取得対象所属コード
	 * @return 所属情報(MSyozokuDto)
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected MSyozokuDto getSectionInfo(
			String sCode
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MSyozokuDao dao = new MSyozokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		return dao.findForKey(sCode);
	}

	/**
	 * 所属情報取得(M_SYOZOKU)
	 * @param sCode 情報取得対象所属コード
	 * @return 所属名称
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String getSectionName(
			String sCode
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		String sName = "";
		MSyozokuDto dto = getSectionInfo(sCode);
		if (dto != null) {
			sName = dto.getSName();
		}
		return sName;
	}

	/**
	 * 所属コード取得
	 * @param kCode 取得対象社員コード
	 * @return 所属コード
	 * @throws NoSuchFieldException 
	 * @throws IllegalAccessException 
	 * @throws SQLException 
	 * @throws MospException 
	 * @throws Exception
	 */
	protected String getBelongSectionCode(
			String kCode
	) throws SQLException, IllegalAccessException, NoSuchFieldException, MospException  {
		String strStationCode = "";
		// 人事基本情報取得
		MKihonDto mKihonDto = getBasisInfo(kCode);
		if (chkExistDto(mKihonDto)) {
			strStationCode = mKihonDto.getSCode();
			// 所属情報取得
			if (strStationCode != null) {
				MSyozokuDao dao = new MSyozokuDao();
				dao.initDao(cfg, cmd, aspUser, user, conn);
				MSyozokuDto dto = dao.findForKey(strStationCode);
				if (chkExistDto(dto)) {
					strStationCode = dto.getSCode();
				} else {
					strStationCode = "";
				}
			}
		}
		return strStationCode;
	}

	/**
	 * 所属コード取得(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getSectionArrayAll() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MSyozokuDao dao = new MSyozokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MSyozokuDto> listSection = dao.findAll();
		// 配列の作成
		String[][] arySection = new String[listSection.size()][2];
		for (int i = 0; i < listSection.size(); i++) {
			arySection[i][0] = listSection.get(i).getSCode();
			arySection[i][1] = listSection.get(i).getSName();
		}
		return arySection;
	}

	/**
	 * 所属コード取得(利用可能…所属のみ)(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws Exception
	 */
	protected String[][] getSectionArrayForManager() throws Exception {
		if (mospUser == null) {
			getInfo(user.getUserId());
		}
		// DAOの準備
		MSyozokuDao dao = new MSyozokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MSyozokuDto> listSection = dao.findForCondition(mKihon.getSCode());
		if (listSection.size() == 0) {
			// メニューに戻る
			String errMessage = MospUtility.getMessage(msg, CommonConst.MSG_NO_AVAILABLE_STA, "");
			addErrMessage(errMessage);
			setNextCmd(MosPMenuAction.CMD_SHOW);
			throw new MospException(CommonConst.EX_NO_AVAILABLE_STA, errMessage);
		}
		// 配列の作成
		String[][] aryStation = new String[listSection.size()][2];
		for (int i = 0; i < listSection.size(); i++) {
			aryStation[i][0] = listSection.get(i).getSCode();
			aryStation[i][1] = listSection.get(i).getSName();
		}
		return aryStation;
	}

	/**
	 * 所属コード取得(利用可能…権限により変化)(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws Exception
	 */
	protected String[][] getSectionArrayForHuman() throws Exception {
		if (mospUser == null) {
			getInfo(user.getUserId());
		}
		// DAOの準備
		MSyozokuDao dao = new MSyozokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MSyozokuDto> listSection;
		// 操作権限確認		
		if (hasHumanAuth()) {
			listSection = dao.findAll();
		} else {
			listSection = dao.findForCondition(mKihon.getSCode());		
		}
		if (listSection.size() == 0) {
			// メニューに戻る
			String errMessage = MospUtility.getMessage(msg, CommonConst.MSG_NO_AVAILABLE_STA, "");
			addErrMessage(errMessage);
			setNextCmd(MosPMenuAction.CMD_SHOW);
			throw new MospException(CommonConst.EX_NO_AVAILABLE_STA, errMessage);
		}
		// 配列の作成
		String[][] aryStation = new String[listSection.size()][2];
		for (int i = 0; i < listSection.size(); i++) {
			aryStation[i][0] = listSection.get(i).getSCode();
			aryStation[i][1] = listSection.get(i).getSName();
		}
		return aryStation;
	}

	/**
	 * 所属コード取得(所属範囲により変化)(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws Exception
	 */
	protected String[][] getSectionScopeArrayForPayroll() throws Exception {
		CmComponentDto cmComponentDto = new CmComponentDto();
		String userAuth = mospUser.getAuthority();
		CmComponentDao cmComponentDao = new CmComponentDao();
		cmComponentDao.initDao(cfg, cmd, aspUser, user, conn);
		CmAuthorityDao cmAuthorityDao = new CmAuthorityDao();
		cmAuthorityDao.initDao(cfg, cmd, aspUser, user, conn);
		CmAuthorityDto cmAuthorityDto;
		cmAuthorityDto = cmAuthorityDao.findForKey(userAuth);
		String [][] ary = null ;
		if (cmAuthorityDto != null) {
			cmComponentDto = cmComponentDao.findForKey(cmAuthorityDto.getPayroll());
		}
		// デフォルトの設定
		if (userAuth.equals(CommonConst.AUTHORITY_CALCULATE)) {
			cmComponentDto.setManage(getManageCode()[2]);
		} else if (userAuth.equals(CommonConst.AUTHORITY_PAYROLL)) {
			cmComponentDto.setManage(getManageCode()[0]);
		}
		// プルダウン設定
		if (cmComponentDto.getManage() == getManageCode()[0]) {
			ary = getSectionArrayForManager();			
		} else if (cmComponentDto.getManage() == getManageCode()[1]) {
			ary = getSectionArrayAll();
		} else {
			ary = util.addArrayFirstRowValue(
					getSectionArrayAll(),
					CommonConst.NAM_COMMON_STRING_INITIAL_VALUE,
					CommonConst.NAM_ALL_SECTION);
		}
		return ary;
	}

	/**
	 * 所属リスト取得(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws Exception
	 */
	protected Map<String, MSyozokuDto> getSectionMap() throws Exception {
		// DAOの準備
		MSyozokuDao dao = new MSyozokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MSyozokuDto> listSection;
		listSection = dao.findAll();
		// 配列の作成
		HashMap<String, MSyozokuDto> map = new HashMap<String, MSyozokuDto>();
		for (int i = 0; i < listSection.size(); i++) {
			map.put(listSection.get(i).getSCode(), listSection.get(i));
		}
		return map;
	}

	/**
	 * 勤務形態コード取得(CM_WORKTYPE)
	 * @return 勤務形態コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getWorkTypeArrayNotDeleted() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MWorkTypeDao dao = new MWorkTypeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MWorkTypeDto> listWorkType = dao.findAvailable();
		// 配列の作成
		String[][] aryWorkType = new String[listWorkType.size()][2];
		for (int i = 0; i < listWorkType.size(); i++) {
			aryWorkType[i][0] = listWorkType.get(i).getShiftCode();
			aryWorkType[i][1] = listWorkType.get(i).getShiftName();
		}
		return aryWorkType;
	}

	/**
	 * 勤務形態コード取得(CM_WORKTYPE)（週休付）
	 * @return 勤務形態コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getWorkTypeArrayWithWeekHoliday() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MWorkTypeDao dao = new MWorkTypeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MWorkTypeDto> listWorkType = dao.findAvailable();
		// 配列の作成
		String[][] aryWorkType = new String[listWorkType.size()][2];
		for (int i = 0; i < listWorkType.size(); i++) {
			aryWorkType[i][0] = listWorkType.get(i).getShiftCode();
			aryWorkType[i][1] = listWorkType.get(i).getShiftName();
		}
		aryWorkType = util.addArrayLastRowValue(aryWorkType,
				CommonConst.ATTENDANCE_TYPE_WEEK_HOLIDAY,
				CommonConst.ATTENDANCE_TYPE_WEEK_HOLIDAY);
		return aryWorkType;
	}

	/**
	 * 勤務形態コード取得(CM_WORKTYPE)
	 * @return 勤務形態コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getWorkTypeArrayAll() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MWorkTypeDao dao = new MWorkTypeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MWorkTypeDto> listWorkType = dao.findAll();
		// 配列の作成
		String[][] aryWorkType = new String[listWorkType.size()][2];
		for (int i = 0; i < listWorkType.size(); i++) {
			aryWorkType[i][0] = listWorkType.get(i).getShiftCode();
			aryWorkType[i][1] = listWorkType.get(i).getShiftName();
		}
		return aryWorkType;
	}

	/**
	 * 勤務形態コード取得(CM_WORKTYPE)
	 * @return 勤務形態コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getWorkTypeArrayAllWithWeekHoliday() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MWorkTypeDao dao = new MWorkTypeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MWorkTypeDto> listWorkType = dao.findAll();
		// 配列の作成
		String[][] aryWorkType = new String[listWorkType.size()][2];
		for (int i = 0; i < listWorkType.size(); i++) {
			aryWorkType[i][0] = listWorkType.get(i).getShiftCode();
			aryWorkType[i][1] = listWorkType.get(i).getShiftName();
		}
		aryWorkType = util.addArrayLastRowValue(aryWorkType,
				CommonConst.ATTENDANCE_TYPE_WEEK_HOLIDAY,
				CommonConst.ATTENDANCE_TYPE_WEEK_HOLIDAY);
		return aryWorkType;
	}

	/**
	 * 勤務形態情報取得(CM_WORKTYPE)
	 * @return 勤務形態コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getWorkTypeDataArray() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MWorkTypeDao dao = new MWorkTypeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MWorkTypeDto> listWorkType = dao.findAll();
		// 配列の作成
		String[][] aryWorkType = new String[listWorkType.size()][8];
		for (int i = 0; i < listWorkType.size(); i++) {
			aryWorkType[i][0] = listWorkType.get(i).getShiftCode();
			aryWorkType[i][1] = listWorkType.get(i).getShiftName();
			aryWorkType[i][2] = String.valueOf(listWorkType.get(i).getStartTime());
			aryWorkType[i][3] = String.valueOf(listWorkType.get(i).getQuitTime());
			aryWorkType[i][4] = String.valueOf(listWorkType.get(i).getWorkTime());
			aryWorkType[i][5] = String.valueOf(listWorkType.get(i).getBreakTime());
			aryWorkType[i][6] = String.valueOf(listWorkType.get(i).getOverStart());
			aryWorkType[i][7] = String.valueOf(listWorkType.get(i).getOverBreak());
		}
		return aryWorkType;
	}

	/**
	 * 勤務形態リスト取得(CM_WORKTYPE)
	 * @return 勤務形態リスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 * @throws ClassNotFoundException 
	 */
	protected Map<String, MWorkTypeDto> getWorkTypeMap(
	) throws SQLException, NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
		// DBコネクション取得
		if (conn == null) {
			getConnection();
		}
		// DAOの準備
		MWorkTypeDao dao = new MWorkTypeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MWorkTypeDto> listWorkType = dao.findAll();
		// Mapの作成
		HashMap<String, MWorkTypeDto> map = new HashMap<String, MWorkTypeDto>();
		for (int i = 0; i < listWorkType.size(); i++) {
			map.put(listWorkType.get(i).getShiftCode(), listWorkType.get(i));
		}
		return map;
	}

	/**
	 * 役職コード取得(M_YAKUSYOKU)
	 * @return 役職コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getPositionArrayAll() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MYakusyokuDao dao = new MYakusyokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MYakusyokuDto> listPosition = dao.findAll();
		// 配列の作成
		String[][] aryPosition = new String[listPosition.size()][3];
		for (int i = 0; i < listPosition.size(); i++) {
			aryPosition[i][0] = listPosition.get(i).getYCode();
			aryPosition[i][1] = listPosition.get(i).getYName();
			aryPosition[i][2] = listPosition.get(i).getTokyu();
		}
		return aryPosition;
	}

	/**
	 * 役職コード取得(等級有りのみ)(M_YAKUSYOKU)
	 * @return 役職コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getPositionArray() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MYakusyokuDao dao = new MYakusyokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MYakusyokuDto> listPosition = dao.findAvailable();
		// 配列の作成
		String[][] aryPosition = new String[listPosition.size()][3];
		for (int i = 0; i < listPosition.size(); i++) {
			aryPosition[i][0] = listPosition.get(i).getYCode();
			aryPosition[i][1] = listPosition.get(i).getYName();
			aryPosition[i][2] = listPosition.get(i).getTokyu();
		}
		return aryPosition;
	}

	/**
	 * 役職コード取得(等級無しのみ)(M_YAKUSYOKU)
	 * @return 役職コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getPositionTitleArray() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MYakusyokuDao dao = new MYakusyokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MYakusyokuDto> listPosition = dao.findForTitle();
		// 配列の作成
		String[][] aryPosition = new String[listPosition.size()][3];
		for (int i = 0; i < listPosition.size(); i++) {
			aryPosition[i][0] = listPosition.get(i).getYCode();
			aryPosition[i][1] = listPosition.get(i).getYName();
		}
		return aryPosition;
	}

	/**
	 * 役職コード取得(プルダウン用)(M_YAKUSYOKU)
	 * @return 役職コードリスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[][] getPositionPltArray() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MYakusyokuDao dao = new MYakusyokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MYakusyokuDto> listPosition = dao.findAvailable();
		// 配列の作成
		String[][] aryPosition = new String[listPosition.size()][2];
		for (int i = 0; i < listPosition.size(); i++) {
			aryPosition[i][0] = listPosition.get(i).getYCode() + CommonConst.STR_TIME_SEPARATOR + listPosition.get(i).getTokyu();
			aryPosition[i][1] = listPosition.get(i).getYName();
		}
		return aryPosition;
	}

	/**
	 * 役職リスト取得(M_YAKUSYOKU)
	 * @return 役職リスト
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected Map<String, MYakusyokuDto> getPositionMap(
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MYakusyokuDao dao = new MYakusyokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// 情報の取得
		List<MYakusyokuDto> listPosition = dao.findAll();
		// Mapの作成
		HashMap<String, MYakusyokuDto> map = new HashMap<String, MYakusyokuDto>();
		for (int i = 0; i < listPosition.size(); i++) {
			map.put(listPosition.get(i).getYCode(), listPosition.get(i));
		}
		return map;
	}

	/**
	 * 役職情報取得(M_YAKUSYOKU)
	 * @param kcode		対象社員コード
	 * @return dto		対象社員役職情報
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected MYakusyokuDto getHoldingPositionInfo(
			String kCode
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MYakusyokuDao dao = new MYakusyokuDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		String positionCode = "";
		String grade = "0";
		// 人事基本情報取得
		MKihonDto mKihonDto = getBasisInfo(kCode);
		if (mKihonDto != null) {
			// 役職情報取得
			positionCode = mKihonDto.getYCode();
			grade = mKihonDto.getTokyu();
		}
		MYakusyokuDto dto = dao.findForKey(positionCode, grade);
		return dto;
	}

	/**
	 * 役職名称取得(等級付き)
	 * @param kCode		対象社員コード
	 * @return	対象社員役職名称
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String getPositionName(
			String kCode
	) throws SQLException, NoSuchFieldException, IllegalAccessException {
		String name = "";
		MKihonDto dto = getBasisInfo(kCode);
		if (dto != null) {
			String position = dto.getYCode() + CommonConst.STR_TIME_SEPARATOR + dto.getTokyu();
			name = util.getCodeName(position, getPositionPltArray());
			if (name.equals(CommonConst.STR_TIME_SEPARATOR)) {
				name = "";
			}
		}
		return name;
	}

	/**
	 * 勤怠締日取得
	 * @return	Date	対象年月日
	 * @throws Exception
	 */
	protected Date getCalcMonth() throws Exception{
		// DAO準備
		MKintaiKeisanDao dao = new MKintaiKeisanDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		MKintaiKeisanDto dto = dao.findForCalc();
		// 対象年月初期値取得
		Date targetDate = util.getSystemDate();
		if (chkExistDto(dto)) {
			int closeDay = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_DAYS)[2]);
			if (closeDay == 0) {
				closeDay = 1;
			}
			targetDate = util.getDate(dto.getKTNen(), dto.getKTTuki(), closeDay);
		}
		return targetDate;
	}

	/**
	 * 勤怠計算月取得
	 * @return yyyymm 計算年月
	 * @throws Exception
	 */
	protected Date getCalcAttendance() throws Exception {
		// 対象年月日取得
		Date targetDate = getCalcMonth();
		// カレンダー取得
		Calendar cal = Calendar.getInstance();
		cal.setTime(targetDate);
		cal.set(Calendar.HOUR_OF_DAY, 0);
		cal.set(Calendar.MINUTE, 0);
		cal.set(Calendar.SECOND, 0);
		cal.set(Calendar.MILLISECOND, 0);
		// 締め日取得
		int minusMonth = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_MONTH)[2]);
		int closeDay   = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_DAYS)[2]);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		cal.roll(Calendar.MONTH, minusMonth * -1);
		if (closeDay != 0) {
			cal.roll(Calendar.MONTH, 1);
			cal.set(Calendar.DAY_OF_MONTH, closeDay);
		}
		return cal.getTime();
	}

	/**
	 * 集計開始日取得
	 * @param targetMonth 対象月
	 * @return 集計開始日
	 * @throws Exception
	 */
	protected Date getStartDate(Date targetMonth) throws Exception {
		// カレンダー取得
		Calendar cal = Calendar.getInstance();
		cal.setTime(targetMonth);
		cal.set(Calendar.HOUR_OF_DAY, 0);
		cal.set(Calendar.MINUTE, 0);
		cal.set(Calendar.SECOND, 0);
		cal.set(Calendar.MILLISECOND, 0);
		// 締め日取得
		int minusMonth = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_MONTH)[2]);
		int closeDay   = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_DAYS)[2]);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		/*						
		 *  	2009/01/20	m.yoshida	締め日対応
		 */
		cal.add(Calendar.MONTH, minusMonth * -1);
		// 集計開始日計算
		if (closeDay != 0) {
			if (MospUtility.getDay(targetMonth) <= closeDay) {
				cal.add(Calendar.MONTH, -1);
			}
			cal.set(Calendar.DAY_OF_MONTH, closeDay);
			cal.add(Calendar.DAY_OF_MONTH, 1);
		}
		return cal.getTime();
	}

	/**
	 * 集計終了日取得
	 * @param targetMonth 対象月
	 * @return 集計終了日
	 * @throws Exception
	 */
	protected Date getEndDate(Date targetMonth) throws Exception {
		// カレンダー取得
		Calendar cal = Calendar.getInstance();
		/*						
		 *  	2009/01/20	m.yoshida	締め日対応
		 */
		// 締め日取得
		int closeDay   = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_DAYS)[2]);
		// 開始日を取得
		cal.setTime(getStartDate(targetMonth));
		// 一ヶ月加算する
		cal.add(Calendar.MONTH, 1);
		if (closeDay != 0) {
			// 指定日締め
			cal.roll(Calendar.DAY_OF_MONTH, -1);
		} else {
			// 末日締め
			cal.add(Calendar.MONTH, -1);
			// 対象月の最終日をセット
			cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
		}
		return cal.getTime();
	}

	/**
	 * 集計月取得
	 * @param targetDate 対象日
	 * @return 集計月
	 * @throws Exception
	 */
	protected Date getCurrentDate(Date targetDate) throws Exception {
		// カレンダー取得
		Calendar cal = Calendar.getInstance();
		cal.setTime(targetDate);
		cal.set(Calendar.HOUR_OF_DAY, 0);
		cal.set(Calendar.MINUTE, 0);
		cal.set(Calendar.SECOND, 0);
		cal.set(Calendar.MILLISECOND, 0);
		// 締め日取得
		int minusMonth = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_MONTH)[2]);
		int closeDay   = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_DAYS)[2]);
		// 集計月取得
		cal.set(Calendar.DAY_OF_MONTH, 1);
		cal.roll(Calendar.MONTH, minusMonth * -1);
		if (closeDay != 0) {
			if (MospUtility.getDay(targetDate) > closeDay) {
				cal.roll(Calendar.MONTH, 1);
			}
		}
		return cal.getTime();
	}

	/**
	 * 給与支給対象年月日取得
	 * @param targetDate 対象日
	 * @return	（勤怠集計月）月（給与支給日）日
	 * @throws Exception
	 */
	protected Date getCalcPayment(Date targetDate) throws Exception {
		// カレンダー取得
		Calendar cal = Calendar.getInstance();
		cal.setTime(targetDate);
		cal.set(Calendar.HOUR_OF_DAY, 0);
		cal.set(Calendar.MINUTE, 0);
		cal.set(Calendar.SECOND, 0);
		cal.set(Calendar.MILLISECOND, 0);
		// 支給日条件取得
		int plusMonth	= Integer.parseInt(getMosPCode(CommonConst.TID_PROVIDED_DATE, CommonConst.TCD_MONTH)[2]);
		int providedDay	= Integer.parseInt(getMosPCode(CommonConst.TID_PROVIDED_DATE, CommonConst.TCD_DAYS)[2]);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		cal.roll(Calendar.MONTH, plusMonth * 1);
		// 1月の場合、支給日条件によって翌年を取得
		if ((cal.get(Calendar.MONTH) == 0)	&& plusMonth != 0) {
			cal.roll(Calendar.YEAR, 1);
		}
		if (providedDay != 0) {
			cal.set(Calendar.DAY_OF_MONTH, providedDay);
		}
		return cal.getTime();
	}

	/**
	 * 給与支給日取得
	 * @return	Date	対象年月日
	 * @throws Exception
	 */
	protected Date getCalcPayment() throws Exception{
		// DAO準備
		MKintaiKeisanDao dao = new MKintaiKeisanDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		MKintaiKeisanDto dto = dao.findForCalc();
		// 対象年月初期値取得
		Date targetDate = getCalcPayment(util.getSystemDate());
		if (chkExistDto(dto)) {
			targetDate = util.getDate(dto.getKSNen(), dto.getKSTuki(), dto.getKShi());
		}
		return targetDate;
	}

	/**
	 * 表示用開始年月日
	 * <p>2009/01/20	m.yoshida	追加</p>
	 * @param targetDate	対象年月日	
	 * @return 表示用開始年月日
	 * @throws Exception
	 */
	protected Date getStartDateForList(Date targetDate) throws Exception {
		// カレンダー取得
		Calendar cal = Calendar.getInstance();
		cal.setTime(targetDate);
		cal.set(Calendar.HOUR_OF_DAY, 0);
		cal.set(Calendar.MINUTE, 0);
		cal.set(Calendar.SECOND, 0);
		cal.set(Calendar.MILLISECOND, 0);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		// 締め日取得
		int closeDay   = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_DAYS)[2]);
		// 集計開始日計算
		if (closeDay != 0) {
			if (MospUtility.getDay(targetDate) <= closeDay) {
				cal.add(Calendar.MONTH, -1);
			}
			cal.set(Calendar.DAY_OF_MONTH, closeDay);
			cal.add(Calendar.DAY_OF_MONTH, 1);
		}
		return cal.getTime();
	}

	/**
	 * 表示用終了年月日
	 * <p>2009/01/20	m.yoshida	追加</p>
	 * @param targetDate	対象年月日
	 * @return 表示用開始年月日
	 * @throws Exception
	 */
	protected Date getEndDateForList(Date targetDate) throws Exception {
		// カレンダー取得
		Calendar cal = Calendar.getInstance();
		// 締め日取得
		int closeDay   = Integer.parseInt(getMosPCode(CommonConst.TID_CALCULATION, CommonConst.TCD_DAYS)[2]);
		// 開始日を取得
		cal.setTime(getStartDateForList(targetDate));
		// 一ヶ月加算する
		cal.add(Calendar.MONTH, 1);
		if (closeDay != 0) {
			// 指定日締め
			cal.roll(Calendar.DAY_OF_MONTH, -1);
		} else {
			// 末日締め
			cal.add(Calendar.MONTH, -1);
			// 対象月の最終日をセット
			cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
		}
		return cal.getTime();
	}

	/**
	 * キー値取得(複合キー)
	 * @param keyIndex キーインデックス
	 * @return キー値
	 */
	protected String getKeyValue(int keyIndex) {
		String[] aryKey= key2.split(CommonConst.KEY_SEPARATOR);
		return aryKey[keyIndex];
	}

	/**
	 * 時間差取得(分)
	 * @param date1 終了日付
	 * @param date2 開始日付
	 * @return 時間差(date1 - date2)
	 * @throws Exception
	 */
	protected long getTimeRemainder(Date date1, Date date2) {
		long timeRemainder = date1.getTime() - date2.getTime();
		return (timeRemainder / (1000 * 60));
	}

	/**
	 * 排他情報取得
	 * @param exclusiveType 排他区分
	 * @param userId        対象ユーザーID
	 * @return 編集者コード(編集者がいない、または自分の場合はnull)
	 * ServletContextを利用するため、複数JVMでの動作は保障しない。
	 */
	protected String getExclusive(int exclusiveType, String userId) {
		listExclusive = (List)ctx.getAttribute(CommonConst.ATT_EXCLUSIVE);
		ExclusiveVo exclusiveVo;
		if (listExclusive == null) {
			return null;
		}
		for (int i = listExclusive.size() - 1; i >= 0; i--) {
			exclusiveVo = (ExclusiveVo)listExclusive.get(i);
			if (exclusiveVo.getExclusiveType() == exclusiveType) {
				if (exclusiveVo.getUserId().equals(userId)) {
					// 自分の排他データを削除
					listExclusive.remove(i);
					continue;
				}
				return exclusiveVo.getUserId();
			}
		}
		return null;
	}

	/**
	 * 排他情報設定
	 * @param exclusiveType 排他区分
	 * @param userId        対象ユーザーID
	 * @param target        編集対象
	 * @return 編集者コード(編集者がいない、または自分の場合はnull)
	 * ServletContextを利用するため、複数JVMでの動作は保障しない。
	 */
	protected String setExclusive(int exclusiveType, String userId, String target) {
		listExclusive = (List)ctx.getAttribute(CommonConst.ATT_EXCLUSIVE);
		ExclusiveVo exclusiveVo;
		String editor = null;
		if (listExclusive == null) {
			listExclusive = new ArrayList();
			ctx.setAttribute(CommonConst.ATT_EXCLUSIVE, listExclusive);
		}
		deleteExclusive(userId);
		for (int i = listExclusive.size() - 1; i >= 0; i--) {
			exclusiveVo = (ExclusiveVo)listExclusive.get(i);
			if (exclusiveVo.getExclusiveType() == exclusiveType && exclusiveVo.getTarget().equals(target)) {
				editor = exclusiveVo.getUserId();
			}
		}
		addList(listExclusive, new ExclusiveVo(exclusiveType, userId, target));
		return editor;
	}

	/**
	 * 排他情報削除
	 * @param userId 対象ユーザーID
	 * ServletContextを利用するため、複数JVMでの動作は保障しない。
	 */
	protected void deleteExclusive(String userId) {
		listExclusive = (List)ctx.getAttribute(CommonConst.ATT_EXCLUSIVE);
		ExclusiveVo exclusiveVo;
		if (listExclusive == null) {
			return;
		}
		for (int i = listExclusive.size() - 1; i >= 0; i--) {
			exclusiveVo = (ExclusiveVo)listExclusive.get(i);
			if (getTimeRemainder(new Date(), exclusiveVo.getDate()) * 60 > Integer.parseInt(cfg.getProperty(MospConst.PPT_APP_INTERVAL))) {
				// セッション保持時間以上経っている排他データを削除
				listExclusive.remove(i);
			} else if (exclusiveVo.getUserId().equals(userId)) {
				// 自分の排他データを削除
				listExclusive.remove(i);
			}
		}
	}

	/**
	 * ファイル作成
	 * @param upfile
	 * @return file
	 * @throws Exception
	 */
	protected File getUploadFile(FileItem upfile) throws Exception {
		// 選択ファイル名取得
		File file = new File(upfile.getFieldName());
		// ファイルへの書き出し
		upfile.write(file);
		return file;
	}

	/**
	 * ファイル作成(CSV)
	 * @param filCsv
	 * @return CSVファイル内容
	 * @throws Exception
	 */
	protected File getCSVFileData(FileItem filCsv) throws Exception {
		// 選択ファイル名取得
		File csvData = new File(filCsv.getFieldName());
		// ファイルへの書き出し
		filCsv.write(csvData);
		return csvData;
	}

	/**
	 * CSVデータパース
	 * @param filCsv
	 * @return CSVファイル内容
	 * @throws Exception
	 */
	protected CSVParser parseCSVData(File filCsv) throws Exception {
		br = new BufferedReader(new FileReader(filCsv));
		CSVParser csvParseData = new CSVParser(br);
		return csvParseData;
	}

	/**
	 * CSVヘッダー作成
	 * @param csvtarget
	 * @return ヘッダ配列
	 * @throws MospException
	 */
	protected String[] getCSVHeadData(CSVParser csvtarget) throws MospException {
		String[] line;
		try {
			line = csvtarget.getLine();
		} catch (IOException e) {
			// 形式エラー
			String errMessage = MospUtility.getMessage(msg, CommonConst.MSG_INVALID_HEAD_TYPE,"");
			addErrMessage(errMessage);
			throw new MospException(MospConst.EX_PARAMS_INVALID);
		}
		return line;
	}

	/**
	 * CSVデータ作成
	 * @param csvtarget
	 * @param idx
	 * @return　データ配列
	 * @throws MospException
	 */
	protected String[] getCSVData(CSVParser csvtarget, int idx) throws MospException {
		String[] line;
		try {
			line = csvtarget.getLine();
		} catch (IOException e) {
			// 形式エラー
			String errMessage = MospUtility.getMessage(msg, CommonConst.MSG_INVALID_DATA_TYPE,String.valueOf(idx + 1));
			addErrMessage(errMessage);
			throw new MospException(MospConst.EX_PARAMS_INVALID);
		}
		return line;
	}

	/**
	 * データ存在確認
	 * @param dto 確認対象DTO
	 * @return boolean	対象DTO存在有無
	 * @throws MospException
	 */
	protected boolean chkExistDto(BaseDto dto) throws MospException {
		if (dto == null) {
			return false;
		}
		return true;
	}

	/**
	 * データ存在確認
	 * @param obj 確認対象Object
	 * @return boolean	対象Object存在有無
	 * @throws MospException
	 */
	protected boolean chkExistObject(Object obj) throws MospException {
		if (obj == null) {
			return false;
		}
		return true;
	}

	/**
	 * 曜日設定
	 * @param dayOfWeek 曜日
	 * @return 曜日名
	 */
	protected String getDayOfWeek(int dayOfWeek) {
		switch (dayOfWeek) {
		case Calendar.SUNDAY:
			return CommonConst.NAM_SUNDAY;
		case Calendar.MONDAY:
			return CommonConst.NAM_MONDAY;
		case Calendar.TUESDAY:
			return CommonConst.NAM_TUESDAY;
		case Calendar.WEDNESDAY:
			return CommonConst.NAM_WEDNESDAY;
		case Calendar.THURSDAY:
			return CommonConst.NAM_THURSDAY;
		case Calendar.FRIDAY:
			return CommonConst.NAM_FRIDAY;
		case Calendar.SATURDAY:
			return CommonConst.NAM_SATURDAY;
		default:
			return "";
		}
	}

	/**
	 * 時間フォーマット
	 * @param hour 時間
	 * @return 時間(文字列)
	 */
	protected String getHourString(double hour) {
		NumberFormat nf = NumberFormat.getNumberInstance();
		nf.setMaximumFractionDigits(2);
		nf.setMinimumFractionDigits(2);
		return nf.format(hour);
	}

	/**
	 * 有給繰越情報
	 * @return	String[]	有給繰越情報
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String[] getPaidHolidayInfo() throws SQLException, NoSuchFieldException, IllegalAccessException {
		String[] aryInfo = new String[3];
		// 繰越月
		aryInfo[0] = getMosPCode(CommonConst.NAM_PAID_HOLIDAY,
				CommonConst.NAM_CARRIED_FORWARD + CommonConst.NAM_MONTH)[2];
		// 繰越日数
		aryInfo[1] = getMosPCode(CommonConst.NAM_PAID_HOLIDAY,
				CommonConst.NAM_CARRIED_FORWARD + CommonConst.NAM_NUMBER_OF_DAYS)[2];
		// 繰越区分
		aryInfo[2] = getMosPCode(CommonConst.NAM_PAID_HOLIDAY, 
				CommonConst.NAM_CARRIED_FORWARD + CommonConst.NAM_COMMON_TYPE)[2];
		return aryInfo;
	}

	/**
	 * 有給休暇支給日数
	 * @return [0]…勤続年数、[1]…支給日数
	 * @throws SQLException
	 * @throws IllegalAccessException
	 * @throws NoSuchFieldException
	 */
	protected String[][] getPaidHolidayArray() throws SQLException, IllegalAccessException, NoSuchFieldException {
		// DAOの準備
		MCodeDao dao = new MCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		List<MCodeDto> listCode = dao.findForHoliday(CommonConst.NAM_PAID_HOLIDAY + CommonConst.NAM_SUPPLY);
		String[][] aryPaidHolidayDays = new String[listCode.size()][2];
		for (int i = 0; i < aryPaidHolidayDays.length; i++) {
			aryPaidHolidayDays[i][0] = listCode.get(i).getTCode();
			aryPaidHolidayDays[i][1] = listCode.get(i).getTChange();
		}
		return aryPaidHolidayDays;
	}

	/**
	 * 出力範囲プルダウンリスト
	 * @return	String[][]	出力範囲配列
	 */
	protected String[][] getOutputScopeArray() {
		// 範囲プルダウンリスト作成
		String[][] aryScope = new String[3][2];
		aryScope[0][0] = CommonConst.CODE_SCOPE_PERSONAL;
		aryScope[0][1] = CommonConst.NAM_SCOPE_PERSONAL;
		aryScope[1][0] = CommonConst.CODE_SCOPE_SECTION;
		aryScope[1][1] = CommonConst.NAM_SCOPE_SECTION;
		aryScope[2][0] = CommonConst.CODE_SCOPE_ALL;
		aryScope[2][1] = CommonConst.NAM_SCOPE_ALL;
		return aryScope;
	}

	/**
	 * 勤怠承認機能状況取得(M_CODE)
	 * @return	boolean 	勤怠承認機能の有効無効
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected boolean isAttendanceApprovalFunction() throws SQLException, NoSuchFieldException, IllegalAccessException {
		// DAOの準備
		MCodeDao dao = new MCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// コードの取得
		MCodeDto dto = dao.findForKey(CommonConst.TID_APPROVAL_FUNCTION, CommonConst.TCD_ATTENDANCE_APPROVAL);     
		if (dto == null) {
			return false;
		} else {
			if (dto.getTName().equals(CommonConst.NAM_COMMON_FLAG_ON)) {
				return false;
			} else if (dto.getTName().equals(CommonConst.NAM_COMMON_FLAG_OFF)) {
				return true;
			} else {
				return false;
			}
		}
	}

	/**
	 * パスワード有効期限日数
	 * @return	int		パスワード有効期限日数
	 * @throws Exception
	 */
	protected int getPasswordTerm() throws Exception {
		int days = 0;
		// DAOの準備
		MCodeDao dao = new MCodeDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		// コードの取得
		MCodeDto dto = dao.findForDto(CommonConst.TID_PASSWORD_TERM);
		if (dto != null) {
			days = Integer.parseInt(dto.getTChange());
		}
		return days;
	}

	/**
	 * フィールド名称内のデータ分解取得
	 *  0 : ファイルID
	 *  1 : 管理番号
	 *  2 : フィールドID
	 *  3 : フィールド名称
	 */
	protected String getEFnameItem(String csvString, int i) {
		//　管理番号取得
		if  (!csvString.equals(""))  {
			String[] arl;
			arl = csvString.split(CommonConst.STR_CSV_SEPARATOR);
			return arl[i];
		}
		return "";
	}

	/**
	 * 該当フラグ配列
	 * @return 該当フラグ配列
	 */
	protected String[][] getCorrespondFlagArray() {
		String[][] array = {
				{ CommonConst.NAM_COMMON_FLAG_OFF,	CommonConst.NAM_DEFAULT_FLAG_OFF	},
				{ CommonConst.NAM_COMMON_FLAG_ON,	CommonConst.NAM_DEFAULT_FLAG_ON		}				
		};
		return array.clone();
	}

	/**
	 * 和暦元号配列
	 * @return	和暦元号配列
	 * @throws Exception
	 */
	protected String[][] getJPCalendarGengo() throws Exception {
		String[][] array = CommonConst.getJpCalendarGengo();
		String[][] aryGengo = getCodeArray(CommonConst.TID_JAPANESE);
		if (aryGengo.length > array.length) {
			array = aryGengo;
		}
		return array;
	}

	/**
	 * 役職手当区分プルダウンリスト（有無＋給与情報単価）
	 * @return 役職手当区分配列
	 */
	protected String[][] getPositionAllowanceType1() {
		String[][] array = {
				{ CommonConst.CODE_ALLOWANCE_NONE, 		CommonConst.NAME_ALLOWANCE_NONE		},
				{ CommonConst.CODE_ALLOWANCE_STATE_1, 	CommonConst.NAME_ALLOWANCE_SALARY	}
		};
		return array.clone();
	}

	/**
	 * 役職手当区分プルダウンリスト（有無＋固定単価）
	 * @return 役職手当区分配列
	 */
	protected String[][] getPositionAllowanceType2() {
		String[][] array = {
				{ CommonConst.CODE_ALLOWANCE_NONE, 		CommonConst.NAME_ALLOWANCE_NONE		},
				{ CommonConst.CODE_ALLOWANCE_STATE_1, 	CommonConst.NAME_ALLOWANCE_FIXED	}
		};
		return array.clone();
	}

	/**
	 * 役職手当区分プルダウンリスト（有無＋給与情報単価＋固定単価）
	 * @return 役職手当区分配列
	 */
	protected String[][] getPositionAllowanceType3() {
		String[][] array = {
				{ CommonConst.CODE_ALLOWANCE_NONE, 		CommonConst.NAME_ALLOWANCE_NONE		},
				{ CommonConst.CODE_ALLOWANCE_STATE_1, 	CommonConst.NAME_ALLOWANCE_SALARY	},
				{ CommonConst.CODE_ALLOWANCE_STATE_2, 	CommonConst.NAME_ALLOWANCE_FIXED	}
		};
		return array.clone();
	}

	/**
	 * DTO同一性チェック
	 * @param formerDto		元対象DTO
	 * @param currentDto	現対象DTO
	 * @return
	 * <p>
	 * 更新日時が同一の場合true、そうでない場合false
	 * </p>
	 * @throws MospException 
	 */
	protected boolean chkIdentityDto(BaseDto formerDto, BaseDto currentDto) throws MospException {
		boolean isSame = false;
		chkExist(currentDto);
		if (formerDto.getUpdateDate().compareTo(currentDto.getUpdateDate()) == 0) {
			isSame = true;
		}
		return isSame;
	}

	/**
	 * 対象年から対象年度を取得
	 * @param year		対象年
	 * @param month		対象月
	 * @param startmonth	年度開始月
	 * @return	対象年度
	 * @throws Exception
	 */
	protected int getTargetFiscalYear(int year, int month, int startmonth) throws Exception {
		// 年度開始月より前月の場合対象年の前年を使用する。
		// 年度開始月より後の月の場合は対象年を使用する
		int fiscalyear = year;
		if (month < startmonth) {
			fiscalyear--;
		}
		return fiscalyear;
	}

	/**
	 * 対象年度から対象年を取得
	 * @param fiscalyear		対象年度
	 * @param month				対象月
	 * @param startmonth		年度開始月
	 * @return	対象年
	 */
	protected int getTargetYear(int fiscalyear, int month, int startmonth) {
		// 年度開始月の前月は対象年度の翌年を利用する
		// 年度開始月の後の月は対象年度を使用する
		int year = fiscalyear;
		if (month < startmonth) {
			year++;
		}
		return year;
	}

	/**
	 * 対象年度開始日取得
	 * @param year		対象年度
	 * @return 対象年度開始日
	 */
	protected Date getFiscalStartDate(int fiscalyear, int startMonth) throws Exception {
		return util.getFirstDateOfMonth(getTargetFiscalYear(fiscalyear, startMonth, startMonth), startMonth);
	}

	/**
	 * 対象年度終了日取得
	 * @param year		対象年度
	 * @return 対象年度終了日
	 */
	protected Date getFiscalEndDate(int fiscalyear, int startMonth) throws Exception {
		return util.getLastDateOfMonth(fiscalyear + 1, startMonth -1);
	}

	/**
	 * 和暦表示設定
	 * @param vo			MosPVoを継承した対象VO
	 * @param targetDate	対象年月日
	 * @return	和暦表示
	 * @throws MospException
	 * @throws Exception
	 */
	protected String getJapaneseDate(MosPVo vo, Date targetDate) throws MospException, Exception {
		return vo.getJapaneseDate(
				getConfList(CommonConst.CONF_ID_JP_IMP_CAL),
				getJPCalendarGengo(),
				targetDate
		);
	}

	/**
	 * 和暦表示設定
	 * @param vo			MosPVoを継承した対象VO
	 * @param targetDate	対象年月日(yyyy-mm-dd)
	 * @return	和暦表示
	 * @throws MospException
	 * @throws Exception
	 */
	protected String getJapaneseDate(MosPVo vo, String targetDate) throws MospException, Exception {
		return vo.getJapaneseDate(
				getConfList(CommonConst.CONF_ID_JP_IMP_CAL),
				getJPCalendarGengo(),
				util.convHyphenDateToDate(targetDate)
		);
	}

	/**
	 * 情報項目用配列取得
	 * @param tableName		対象テーブル名
	 * @return	 情報項目用配列
	 * @throws SQLException
	 * @throws IllegalAccessException
	 * @throws NoSuchFieldException
	 * @throws MospException
	 */
	protected String[] getTableColumnInfo(
			String tableName
	) throws SQLException, IllegalAccessException, NoSuchFieldException, MospException {
		MExportColumnDao dao = new MExportColumnDao();
		dao.initDao(cfg, cmd, aspUser, user, conn);
		List<MExportColumnDto> list = dao.findForCondition(tableName);
		String[] aryColumnInfo = new String[list.size()];
		int i = 0;
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			MExportColumnDto dto = (MExportColumnDto) iter.next();
			StringBuffer sb = new StringBuffer();
			sb.append(tableName.toUpperCase(Locale.JAPANESE));
			sb.append(CommonConst.STR_UNDER_SEPARATOR);
			sb.append(i + 1);
			sb.append(CommonConst.STR_UNDER_SEPARATOR);
			sb.append(dto.getColumnField().toUpperCase(Locale.JAPANESE));
			sb.append(CommonConst.STR_UNDER_SEPARATOR);
			sb.append(dto.getColumnComment());
			aryColumnInfo[i] = sb.toString();
			i++;
		}
		return aryColumnInfo;
	}

	/**
	 * エクスポート情報項目設定
	 * @param strFLID	対象テーブルコード
	 * @return	String[][]	エクスポート情報項目配列
	 * @throws Exception
	 */
	protected String[][] getKintaiDataItem(String strFLID) throws Exception {
		ExportInfoUtility exportUtility = new ExportInfoUtility(
				getTableColumnInfo(jp.mosp.human.dao.MKihonDao.TABLE),
				getTableColumnInfo(jp.mosp.payroll.dao.MKintaiDao.TABLE),
				getTableColumnInfo(jp.mosp.kintai.dao.MSyukkinboDao.TABLE),
				getTableColumnInfo(jp.mosp.kintai.dao.MYukyuDao.TABLE)
		);
		return exportUtility.getKintaiDataItem(strFLID);
	}

	/**
	 * 承認ステータスコードリスト取得
	 * @return 承認ステータスコードリスト配列
	 */
	protected String[] getApprovalStatusCodeArray() {
		// 配列の作成
		String[] aryStatus = new String[5];
		aryStatus[0] = CommonConst.NUM_ATTENDANCE_REQUEST;
		aryStatus[1] = CommonConst.NUM_ATTENDANCE_1ST_APPROVED;
		aryStatus[2] = CommonConst.NUM_ATTENDANCE_1ST_RETURNED;
		aryStatus[3] = CommonConst.NUM_ATTENDANCE_2ND_APPROVED;
		aryStatus[4] = CommonConst.NUM_ATTENDANCE_2ND_RETURNED;
		return aryStatus;
	}

	/* (non-Javadoc)
	 * @see jp.mosp.common.common.BaseAction#getConnection()
	 */
	protected void getConnection() throws ClassNotFoundException, SQLException {
		boolean isDefault = true;
		// DataSourceが利用できるか判断
		if (canUseDataSource()) {
			try {
				getConnection(cfg.getProperty(MospConst.PPT_ASP_DSOURCE));
			} catch (Exception e) {
				// エラーをログに出力する。
				LogUtility.log(cfg, "", "", cmd, 5, MospConst.LOG_MOSPERR, MospConst.LOG_MSG_5003);
			} finally {
				if (conn != null) {
					isDefault = false;
				} else {
					// 設定がエラーの場合、デフォルトの接続を利用する。
					cfg.setProperty(CommonConst.PPT_USE_DATA_SOURCE, String.valueOf(false));
				}
			}
		}
		if (isDefault) {
			super.getConnection();
		}
	}

	/**
	 * DataSource利用可否判断
	 * @return
	 * <p>
	 * DataSourceが利用できる場合true、そうでない場合false<br>
	 * 一度判断したら、cfgにセットし次回からそちらを利用する。
	 * </p>
	 */
	protected boolean canUseDataSource() {
		// 設定ファイルのプロパティから取得
		String pptDataSource = cfg.getProperty(CommonConst.PPT_USE_DATA_SOURCE);
		if (pptDataSource == null) {
			// プロパティに無い場合、設定する。
			boolean dsourceFlag = false;
			if (DataSourceUtility.canUseDataSource(cfg.getProperty(MospConst.PPT_ASP_DSOURCE))) {
				dsourceFlag = true;
				LogUtility.log(cfg, "", "", "", 4, MospConst.LOG_MOSPINF, DataSourceUtility.USE_DATA_SOURCE_MESSAGE);
			}
			cfg.setProperty(CommonConst.PPT_USE_DATA_SOURCE, String.valueOf(dsourceFlag));
			pptDataSource = String.valueOf(dsourceFlag);
		}
		return Boolean.valueOf(pptDataSource);
	}

	/**
	 * 初期コマンド取得。<br>
	 * @param invalidProcSeq 処理シーケンス不正時フラグ
	 * @return 初期コマンド
	 */
	@Override
	protected String getIndexCommand(boolean invalidProcSeq) {
		try {
			// ASPユーザー取得(設定ファイルのASP設定で判断)
			switch (MospUtility.getAspFlag(cfg)) {
			case 0:
			case 1:
				// 0：ASP(xユーザー:1アプリ)
				// 1：ASP(1ユーザー:1アプリ)
				return "C3011";
			case 2:
				// 2：非ASP
				return MospConst.CMD_INDEX;
			default:
				return MospConst.CMD_INDEX;
			}
		} catch (MospException e) {
			return MospConst.CMD_INDEX;
		}
	}

	/*
	 * 以下、オプション関連のメソッド
	 */	

	/**
	 * OptionConst取得
	 * @return	OptionConstのクラスオブジェクト
	 * @throws ClassNotFoundException
	 */
	protected Class getOptionConstClass() throws ClassNotFoundException {
		return Class.forName(CommonConst.OPTION_CONST_FULLNAME);
	}

	/**
	 * オプション機能有効判定
	 * <p>2008/12/10	m.yoshida	追加</p>
	 * @return useOption
	 * <p>
	 * オプション機能を利用することができる場合true、<br>
	 * そうでない場合false
	 * </p>
	 */
	protected boolean canUseOptionPackage() {
		// 設定ファイルのプロパティから取得
		try {
			if (cfg.getProperty(CommonConst.PPT_USE_OPTION) == null) {
				// OptionConstクラスが存在するか確認
				Class cls = getOptionConstClass();
				// プロパティに無い場合、設定する。
				if (cls != null) {
					cfg.setProperty(CommonConst.PPT_USE_OPTION, String.valueOf(true));
				}
			}
		} catch (ClassNotFoundException e) {
			cfg.setProperty(CommonConst.PPT_USE_OPTION, String.valueOf(false));
		}
		return Boolean.valueOf(cfg.getProperty(CommonConst.PPT_USE_OPTION));
	}

	/**
	 * 閲覧権限コード配列取得
	 * @return	閲覧権限コード配列
	 * <p>
	 * [0]…所属部署
	 * [1]…選択部署
	 * [2]…全部署
	 * </p>
	 */
	protected int[] getManageCode() {
		int[] aryCode = new int[3];
		aryCode[0] = Integer.parseInt(CommonConst.NUM_BELONGING_SECTION);
		aryCode[1] = Integer.parseInt(CommonConst.NUM_SELECT_SECTION);
		aryCode[2] = Integer.parseInt(CommonConst.NUM_ALL_SECTION);
		return aryCode;
	}

	/**
	 * 閲覧権限プルダウンリスト
	 * @return	String[][]	出力範囲配列
	 */
	protected String[][] getManageArray() {
		// 範囲プルダウンリスト作成
		String[][] aryScope = new String[3][2];
		aryScope[0][0] = String.valueOf(getManageCode()[0]);
		aryScope[0][1] = CommonConst.NAM_BELONGING_SECTION;
		aryScope[1][0] = String.valueOf(getManageCode()[1]);
		aryScope[1][1] = CommonConst.NAM_SELECT_SECTION;
		aryScope[2][0] = String.valueOf(getManageCode()[2]);
		aryScope[2][1] = CommonConst.NAM_ALL_SECTION;
		return aryScope;
	}

	// アクセサメソッド
	protected void setNeedExclusive(boolean needExclusive) { this.needExclusive = needExclusive; }

}
