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

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
//import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.ArrayList;

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

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

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.dto.CmAspUserDto;
import jp.mosp.common.dto.CmUserDto;
import jp.mosp.common.dto.MosPConfDto;
import jp.mosp.common.part.BasePart;

import jp.mosp.common.part.DatePart;
import jp.mosp.common.part.PartInfo;
import jp.mosp.common.part.PartManager;
import jp.mosp.common.part.VariousPart;
import jp.mosp.common.vo.ExclusiveVo;

import jp.mosp.human.dto.MKihonDto;

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

/**
 * MosPのベースとなるActionクラス
 * @author yoshida
 *	@version	0.1.1
 */
public abstract class MosPAction extends BaseAction {

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

	// フィールド
	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);
		StringBuffer filepath = new StringBuffer();
		filepath.append(cfg.getProperty(MospConst.PPT_APP_DOCBASE));
		filepath.append(System.getProperty("file.separator"));
		filepath.append("pub");
		filepath.append(System.getProperty("file.separator"));
		filepath.append(CommonConst.FILE_LOGO);
		if (useLogo != null 
				&& useLogo.length() != 0 
				&& Boolean.parseBoolean(useLogo) 
				&& new File(filepath.toString()).exists()
		) {
			useLogoFlag = true;
		}
		cfg.setProperty(CommonConst.PPT_USE_LOGO, String.valueOf(useLogoFlag));
	}

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

	/**
	 * PartClass初期化情報
	 * @since	0.1.0
	 */
	private PartInfo partInfo;

	/**
	 * PartInfoインスタンスの生成
	 * <p>	一度生成した場合、使いまわす。	</p>
	 * @return	PartInfoインスタンス
	 * @throws SQLException 
	 * @throws ClassNotFoundException 
	 * @since	0.1.0
	 */
	protected PartInfo partInfo() throws ClassNotFoundException, SQLException {
		if (!VariousPart.chkExistObject(partInfo)) {
			// DBコネクション取得
			if (conn == null) {
				getConnection();
			}
			partInfo = PartManager.createPartInfo(cfg, cmd, aspUser, user, conn);
		}
		return partInfo;
	}

	/**
	 * 削除フラグリスト取得
	 * @return 削除フラグリスト
	 */
	protected String[][] getDeleteArray() {
		return VariousPart.getDeleteArray();
	}

	/**
	 * 適用フラグリスト取得
	 * @return 削除フラグリスト
	 */
	protected String[][] getApplicableFlagArray() {
		return VariousPart.getApplicableFlagArray();
	}

	/**
	 * 設定リスト取得(MOSP_CONF)
	 * @param confId 設定区分
	 * @return 設定リスト
	 * @throws Exception
	 */
	protected String[][] getConfArray(String confId) throws Exception {
		return PartManager.mospconf(partInfo()).getConfArray(confId);
	}

	/**
	 * 設定値取得(MOSP_CONF)
	 * @param confId   設定区分
	 * @param confCode 設定コード
	 * @return 設定値
	 * @throws Exception
	 */
	protected String getConfValue(String confId, String confCode) throws Exception {
		return PartManager.mospconf(partInfo()).getConfValue(confId, confCode);
	}

	/**
	 * 設定リスト取得(MOSP_CONF)
	 * @param confId 設定区分
	 * @return 設定リスト
	 * @throws Exception 
	 */
	protected List<MosPConfDto> getConfList(
			String confId
	) throws Exception  {
		return PartManager.mospconf(partInfo()).getConfList(confId);
	}

	/**
	 * ユーザー情報取得
	 * @param userId 対象ユーザーID
	 * @throws Exception 
	 */
	protected void getInfo(
			String userId
	) throws Exception {
		mKihon 		= PartManager.human(partInfo()).getBasisInfo(user.getKCode());
	}

	/**
	 * 人事基本情報取得(M_KIHON)
	 * @param kCode 情報取得対象社員コード
	 * @return 人事基本情報(UmBasisDto)
	 * @throws Exception 
	 */
	protected MKihonDto getBasisInfo(
			String kCode
	) throws Exception {
		return PartManager.human(partInfo()).getBasisInfo(kCode);
	}

	/**
	 * 社員氏名取得(M_KIHON)
	 * @param kCode 情報取得対象社員コード
	 * @return 社員氏名
	 * @throws Exception 
	 */
	protected String getKName(
			String kCode
	) throws Exception {
		return PartManager.human(partInfo()).getKName(kCode);
	}

	/**
	 * 社員コード取得(M_KIHON)(現所属)
	 * @param sectionCode 検索所属コード
	 * @return 社員コードリスト
	 * @throws Exception 
	 */
	protected String[] getBasisArray(
			String sectionCode
	) throws Exception {
		return PartManager.human(partInfo()).getBasisArray(sectionCode);
	}

	/**
	 * 社員コード取得(M_KIHON)(指定年月日所属)
	 * @param sectionCode 検索所属コード
	 * @param targetMonth 選択年月日
	 * @return 社員コードリスト
	 * @throws Exception 
	 */
	protected String[] getBasisArray(
			String sectionCode,
			Date targetMonth
	) throws Exception {
		return PartManager.human(partInfo()).getBasisArray(sectionCode);
	}

	/**
	 * 社員コード取得(M_KIHON)
	 * @return 社員コードリスト
	 * @throws Exception 
	 */
	protected String[][] getBasisArrayAll() throws Exception {
		return PartManager.human(partInfo()).getBasisArrayAll();
	}

	/**
	 * 社員コード取得(M_KIHON)
	 * @return 社員コードリスト
	 * @throws Exception 
	 */
	protected String[][] getBasisArrayForApproval() throws Exception {
		return PartManager.human(partInfo()).getBasisArrayForApproval();
	}

	/**
	 * 社員コード、所属コード取得(M_KIHON)
	 * @return 社員コードリスト
	 * @throws Exception 
	 */
	protected String[][] getBasisArrayAllWithSectionCode() throws Exception {
		return PartManager.human(partInfo()).getBasisArrayAllWithSectionCode();
	}


	/**
	 * 社員コード、事業所コード取得(M_KIHON)
	 * @return 社員コードリスト
	 * @throws Exception 
	 */
	protected String[][] getBasisArrayAllWithOfficeCode() throws Exception {
		return PartManager.human(partInfo()).getBasisArrayAllWithOfficeCode();
	}

	/**
	 * 選択社員所属社員コード一覧取得(M_KIHON)
	 * @param kcode		対象社員コード
	 * @return	社員コードリスト
	 * @throws Exception
	 */
	protected String[][] getBasisArrayForBelongSection(String kcode) throws Exception {
		return PartManager.human(partInfo()).getBasisArrayForBelongSection(kcode);
	}

	/**
	 * 勤続年数（月数）取得
	 * @param kCode
	 * @return y.m<br>月はそのまま
	 * 				[例] 26月→2.02年
	 * @throws Exception 
	 */
	protected double getYearsOfService(
			String kCode
	) throws Exception {
		return PartManager.human(partInfo()).getYearsOfService(kCode);
	}

	/**
	 * 在職社員情報取得
	 * @param kCode		対象社員コード
	 * @return			在職社員情報
	 * @throws Exception
	 */
	protected MKihonDto getAvailableUserInfo(String kCode) throws Exception {
		return PartManager.human(partInfo()).getAvailableUserInfo(kCode);
	}

	/**
	 * 退職判断
	 * @param kCode		対象社員コード
	 * @return
	 * <p>
	 * 退職の場合。true、そうでない場合false。
	 * </p>
	 * @throws Exception
	 */
	protected boolean isRetiredEmployee (String kCode) throws Exception {
		return PartManager.human(partInfo()).isRetiredEmployee(kCode);
	}

	/**
	 * コードリスト取得(CM_CODE)
	 * @param tId コード区分
	 * @return コードリスト
	 * @throws Exception 
	 */
	@Override
	protected String[][] getCodeArray(String tId) throws Exception {
		return PartManager.cmcode(partInfo()).getCodeArray(tId);
	}

	/**
	 * コード区分取得(CM_CODE)
	 * @return コード区分リスト
	 * @throws Exception 
	 */
	protected String[][] getCodeArray() throws Exception {
		return PartManager.cmcode(partInfo()).getCodeArray();
	}

	/**
	 * コード区分名称取得(CM_CODE)
	 * @param	tId コード区分
	 * @return	tId コード区分名称
	 * @throws MospException 
	 */
	protected String getCodeTypeName(String tId) throws Exception {
		return PartManager.cmcode(partInfo()).getCodeTypeName(tId);
	}

	/**
	 * 権限コードリスト取得(CM_AUTHORITY)
	 * @return コードリスト
	 * @throws Exception 
	 */
	protected String[][] getArrangeAuthArray() throws Exception {
		return PartManager.authority(partInfo()).getArrangeAuthArray();
	}

	/**
	 * 全権限コードリスト取得(CM_AUTHORITY)
	 * @return コードリスト
	 * @throws Exception 
	 */
	protected String[][] getArrangeAuthArrayAll() throws Exception {
		return PartManager.authority(partInfo()).getArrangeAuthArrayAll();
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード区分リスト
	 * @throws Exception 
	 */
	protected String[][] getMosPCodeArray() throws Exception {
		return PartManager.mospcode(partInfo()).getMosPCodeArray();
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * @param tid コードID
	 * @throws Exception 
	 */
	protected String[][] getMosPCodeArray(String tid) throws Exception {
		return PartManager.mospcode(partInfo()).getMosPCodeArray(tid);
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * 			[2]tchange
	 * @param tid コードID
	 * @throws Exception 
	 */
	protected String[][] getMosPCodeArray(String tid, String tcode) throws Exception {
		return PartManager.mospcode(partInfo()).getMosPCodeArray(tid, tcode);
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * 			[2]tchange
	 * @param tid コードID
	 * @throws Exception 
	 */
	protected String[] getMosPCode(String tid, String tcode) throws Exception {
		return PartManager.mospcode(partInfo()).getMosPCode(tid, tcode);
	}

	/**
	 * 理由区分取得(M_CODE)
	 * @param tid コードID
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * @throws Exception 
	 */
	protected String[][] getReasonCodeArray(String tid) throws Exception {
		return PartManager.mospcode(partInfo()).getReasonCodeArray(tid);
	}

	/**
	 * コード区分取得(M_CODE)
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * 			[2]tchange
	 * @param tid コードID
	 * @throws Exception 
	 */
	protected String[] getMosPCode(String tid) throws Exception {
		return PartManager.mospcode(partInfo()).getMosPCode(tid);
	}

	/**
	 * ユーザー情報取得(CM_USER)
	 * @param userId 情報取得対象ユーザーID
	 * @return ユーザー情報(CmUserDto)
	 * @throws Exception 
	 */
	protected CmUserDto getUserInfo(
			String userId
	) throws Exception {
		return PartManager.mospuser(partInfo()).getUserInfo(userId);
	}

	/**
	 * ユーザー情報取得(MOSP_USER)
	 * @param kcode		情報取得対象社員コード
	 * @return ユーザー情報(CmUserDto)
	 * @throws Exception 
	 */
	protected CmUserDto getUserInfoForKCode(String kcode) throws Exception {
		return PartManager.mospuser(partInfo()).getUserInfoForKCode(kcode);
	}

	/**
	 * MANAGER権限確認
	 * @return TRAINER権限有無(true：権限有、false：権限無)
	 * @throws Exception
	 */
	protected boolean hasManagerAuth() throws Exception {
		return PartManager.authority(partInfo()).hasManagerAuth();
	}


	/**
	 * 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 {
		return PartManager.authority(partInfo()).hasPayrollAuth();
	}

	/**
	 * 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 {
		return PartManager.authority(partInfo()).hasHumanAuth();
	}

	/**
	 * 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 {
		return PartManager.authority(partInfo()).hasCalculateAuth();
	}

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

	/**
	 * SYSTEM権限確認
	 * @return SYSTEM権限有無(true：権限有、false：権限無)
	 * @throws Exception 
	 */
	protected boolean hasSystemAuth() throws Exception {
		return PartManager.authority(partInfo()).hasSystemAuth();
	}

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

	/**
	 * 事業所情報取得(M_KAISYA)
	 * @param jCode 情報取得対象事業所コード
	 * @return 事業所情報(MKaisyaDto)
	 * @throws Exception 
	 */
	protected MKaisyaDto getOfficeInfo(
			String jCode
	) throws Exception {
		return PartManager.office(partInfo()).getOfficeInfo(jCode);
	}

	/**
	 * 事業所コード取得(M_KAISYA)
	 * @return 事業所コードリスト
	 * @throws Exception 
	 */
	protected String[][] getOfficeArrayAll() throws Exception {
		return PartManager.office(partInfo()).getOfficeArrayAll();
	}

	/**
	 * 事業所コード取得(利用可能所属のみ)(M_KAISYA)
	 * @return 事業所コードリスト
	 * @throws Exception
	 */
	protected String[][] getOfficeArray() throws Exception {
		return PartManager.office(partInfo()).getOfficeArray();
	}

	/**
	 * 事業所コード取得（所属のみ）(M_KAISYA)
	 * @param kCode 取得対象社員コード
	 * @return 事業所コード
	 * @throws Exception
	 */
	protected String getBelongOfficeCode(String kCode) throws Exception {
		return PartManager.office(partInfo()).getBelongOfficeCode(kCode);
	}

	/**
	 * 所属情報取得(M_SYOZOKU)
	 * @param sCode 情報取得対象所属コード
	 * @return 所属情報(MSyozokuDto)
	 * @throws Exception 
	 */
	protected MSyozokuDto getSectionInfo(
			String sCode
	) throws Exception {
		return PartManager.section(partInfo()).getSectionInfo(sCode);
	}

	/**
	 * 所属情報取得(M_SYOZOKU)
	 * @param sCode 情報取得対象所属コード
	 * @return 所属名称
	 * @throws Exception 
	 */
	protected String getSectionName(
			String sCode
	) throws Exception {
		return PartManager.section(partInfo()).getSectionName(sCode);
	}

	/**
	 * 所属コード取得
	 * @param kCode 取得対象社員コード
	 * @return 所属コード
	 * @throws Exception
	 */
	protected String getBelongSectionCode(
			String kCode
	) throws Exception {
		return PartManager.section(partInfo()).getBelongSectionCode(kCode);
	}

	/**
	 * 所属コード取得(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws Exception 
	 */
	protected String[][] getSectionArrayAll() throws Exception {
		return PartManager.section(partInfo()).getSectionArrayAll();
	}

	/**
	 * 所属コード取得(利用可能…所属のみ)(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws Exception
	 */
	protected String[][] getSectionArrayForManager() throws Exception {
		return PartManager.section(partInfo()).getSectionArrayForManager();
	}

	/**
	 * 所属コード取得(利用可能…権限により変化)(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws Exception
	 */
	protected String[][] getSectionArrayForHuman() throws Exception {
		return PartManager.section(partInfo()).getSectionArrayForHuman();
	}

	/**
	 * 所属コード取得(所属範囲により変化)(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws Exception
	 */
	protected String[][] getSectionScopeArrayForPayroll() throws Exception {
		return PartManager.section(partInfo()).getSectionScopeArrayForPayroll();
	}

	/**
	 * 所属リスト取得(M_SYOZOKU)
	 * @return 所属コードリスト
	 * @throws Exception
	 */
	protected Map<String, MSyozokuDto> getSectionMap() throws Exception {
		return PartManager.section(partInfo()).getSectionMap();
	}

	/**
	 * 勤務形態コード取得(CM_WORKTYPE)
	 * @return 勤務形態コードリスト
	 * @throws Exception 
	 */
	protected String[][] getWorkTypeArrayNotDeleted() throws Exception {
		return PartManager.worktype(partInfo()).getWorkTypeArrayNotDeleted();
	}

	/**
	 * 勤務形態コード取得(CM_WORKTYPE)（週休付）
	 * @return 勤務形態コードリスト
	 * @throws Exception 
	 */
	protected String[][] getWorkTypeArrayWithWeekHoliday() throws Exception {
		return PartManager.worktype(partInfo()).getWorkTypeArrayWithWeekHoliday();
	}

	/**
	 * 勤務形態コード取得(CM_WORKTYPE)
	 * @return 勤務形態コードリスト
	 * @throws Exception 
	 */
	protected String[][] getWorkTypeArrayAll() throws Exception {
		return PartManager.worktype(partInfo()).getWorkTypeArrayAll();
	}

	/**
	 * 勤務形態コード取得(CM_WORKTYPE)
	 * @return 勤務形態コードリスト
	 * @throws Exception 
	 */
	protected String[][] getWorkTypeArrayAllWithWeekHoliday() throws Exception {
		return PartManager.worktype(partInfo()).getWorkTypeArrayAllWithWeekHoliday();
	}

	/**
	 * 勤務形態情報取得(CM_WORKTYPE)
	 * @return 勤務形態コードリスト
	 * @throws Exception 
	 */
	protected String[][] getWorkTypeDataArray() throws Exception {
		return PartManager.worktype(partInfo()).getWorkTypeDataArray();
	}

	/**
	 * 勤務形態リスト取得(CM_WORKTYPE)
	 * @return 勤務形態リスト
	 * @throws Exception 
	 */
	protected Map<String, MWorkTypeDto> getWorkTypeMap() throws Exception {
		return PartManager.worktype(partInfo()).getWorkTypeMap();
	}

	/**
	 * 役職コード取得(M_YAKUSYOKU)
	 * @return 役職コードリスト
	 * @throws Exception 
	 */
	protected String[][] getPositionArrayAll() throws Exception {
		return PartManager.position(partInfo()).getPositionArrayAll();
	}

	/**
	 * 役職コード取得(等級有りのみ)(M_YAKUSYOKU)
	 * @return 役職コードリスト
	 * @throws Exception 
	 */
	protected String[][] getPositionArray() throws Exception {
		return PartManager.position(partInfo()).getPositionArray();
	}

	/**
	 * 役職コード取得(等級無しのみ)(M_YAKUSYOKU)
	 * @return 役職コードリスト
	 * @throws Exception 
	 */
	protected String[][] getPositionTitleArray() throws Exception {
		return PartManager.position(partInfo()).getPositionTitleArray();
	}

	/**
	 * 役職コード取得(プルダウン用)(M_YAKUSYOKU)
	 * @return 役職コードリスト
	 * @throws Exception 
	 */
	protected String[][] getPositionPltArray() throws Exception {
		return PartManager.position(partInfo()).getPositionPltArray();
	}

	/**
	 * 役職リスト取得(M_YAKUSYOKU)
	 * @return 役職リスト
	 * @throws Exception 
	 */
	protected Map<String, MYakusyokuDto> getPositionMap() throws Exception {
		return PartManager.position(partInfo()).getPositionMap();
	}

	/**
	 * 役職情報取得(M_YAKUSYOKU)
	 * @param kcode		対象社員コード
	 * @return dto		対象社員役職情報
	 * @throws Exception 
	 */
	protected MYakusyokuDto getHoldingPositionInfo(
			String kCode
	) throws Exception {
		return PartManager.position(partInfo()).getHoldingPositionInfo(kCode);
	}

	/**
	 * 役職名称取得(等級付き)
	 * @param kCode		対象社員コード
	 * @return	対象社員役職名称
	 * @throws Exception 
	 */
	protected String getPositionName(String kCode) throws Exception {
		return PartManager.position(partInfo()).getPositionName(kCode);
	}

	/**
	 * 勤怠締日取得
	 * @return	Date	対象年月日
	 * @throws Exception
	 */
	protected Date getCalcMonth() throws Exception {
		return PartManager.calculate(partInfo()).getCalcMonth();
	}

	/**
	 * 勤怠計算月取得
	 * @return yyyymm 計算年月
	 * @throws Exception
	 */
	protected Date getCalcAttendance() throws Exception {
		return PartManager.calculate(partInfo()).getCalcAttendance();
	}

	/**
	 * 集計開始日取得
	 * @param targetMonth 対象月
	 * @return 集計開始日
	 * @throws Exception
	 */
	protected Date getStartDate(Date targetMonth) throws Exception {
		return PartManager.calculate(partInfo()).getStartDate(targetMonth);
	}

	/**
	 * 集計終了日取得
	 * @param targetMonth 対象月
	 * @return 集計終了日
	 * @throws Exception
	 */
	protected Date getEndDate(Date targetMonth) throws Exception {
		return PartManager.calculate(partInfo()).getEndDate(targetMonth);
	}

	/**
	 * 集計月取得
	 * @param targetDate 対象日
	 * @return 集計月
	 * @throws Exception
	 */
	protected Date getCurrentDate(Date targetDate) throws Exception {
		return PartManager.calculate(partInfo()).getCurrentDate(targetDate);
	}

	/**
	 * 給与支給対象年月日取得
	 * @param targetDate 対象日
	 * @return	（勤怠集計月）月（給与支給日）日
	 * @throws Exception
	 */
	protected Date getCalcPayment(Date targetDate) throws Exception {
		return PartManager.calculate(partInfo()).getCalcPayment(targetDate);
	}

	/**
	 * 給与支給日取得
	 * @return	Date	対象年月日
	 * @throws Exception
	 */
	protected Date getCalcPayment() throws Exception {
		return PartManager.calculate(partInfo()).getCalcPayment();
	}

	/**
	 * 表示用開始年月日
	 * <p>2009/01/20	m.yoshida	追加</p>
	 * @param targetDate	対象年月日	
	 * @return 表示用開始年月日
	 * @throws Exception
	 */
	protected Date getStartDateForList(Date targetDate) throws Exception {
		return PartManager.calculate(partInfo()).getStartDateForList(targetDate);
	}

	/**
	 * 表示用終了年月日
	 * <p>2009/01/20	m.yoshida	追加</p>
	 * @param targetDate	対象年月日
	 * @return 表示用開始年月日
	 * @throws Exception
	 */
	protected Date getEndDateForList(Date targetDate) throws Exception {
		return PartManager.calculate(partInfo()).getEndDateForList(targetDate);
	}

	/**
	 * キー値取得(複合キー)
	 * @param keyIndex キーインデックス
	 * @return キー値
	 */
	protected String getKeyValue(int keyIndex) {
		return VariousPart.getKeyValue(key2, keyIndex);
	}

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

	/**
	 * 排他情報取得
	 * @param exclusiveType 排他区分
	 * @param userId        対象ユーザーID
	 * @return 編集者コード(編集者がいない、または自分の場合はnull)
	 * ServletContextを利用するため、複数JVMでの動作は保障しない。
	 */
	@SuppressWarnings("unchecked")
	protected String getExclusive(int exclusiveType, String userId) {
		listExclusive = (List<ExclusiveVo>)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での動作は保障しない。
	 */
	@SuppressWarnings("unchecked")
	protected String setExclusive(int exclusiveType, String userId, String target) {
		listExclusive = (List<ExclusiveVo>)ctx.getAttribute(CommonConst.ATT_EXCLUSIVE);
		ExclusiveVo exclusiveVo;
		String editor = null;
		if (listExclusive == null) {
			listExclusive = new ArrayList<ExclusiveVo>();
			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での動作は保障しない。
	 */
	@SuppressWarnings("unchecked")
	protected void deleteExclusive(String userId) {
		listExclusive = (List<ExclusiveVo>)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 InputStreamReader(
				new FileInputStream(filCsv), Charset.forName("JISAutoDetect"))
		);
		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) {
		return VariousPart.chkExistDto(dto);
	}

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

	/**
	 * 曜日設定
	 * @param dayOfWeek 曜日
	 * @return 曜日名
	 */
	protected String getDayOfWeek(int dayOfWeek) {
		return VariousPart.getDayOfWeek(dayOfWeek);
	}

	/**
	 * 時間フォーマット
	 * @param hour 時間
	 * @return 時間(文字列)
	 */
	protected String getHourString(double hour) {
		return VariousPart.getHourString(hour);
	}

	/**
	 * 有給繰越情報
	 * @return	String[]	有給繰越情報
	 * <p>
	 * [0]...繰越月、
	 * [1]...繰越日数、
	 * [2]...繰越区分
	 * </p>
	 * @throws Exception 
	 */
	protected String[] getPaidHolidayInfo() throws Exception {
		return PartManager.mospcode(partInfo()).getPaidHolidayInfo();
	}

	/**
	 * 有給休暇支給日数
	 * @return [0]…勤続年数、[1]…支給日数
	 * @throws Exception 
	 */
	protected String[][] getPaidHolidayArray() throws Exception {
		return PartManager.mospcode(partInfo()).getPaidHolidayArray();
	}

	/**
	 * 出力範囲プルダウンリスト
	 * @return	String[][]	出力範囲配列
	 */
	protected String[][] getOutputScopeArray() {
		return VariousPart.getOutputScopeArray();
	}

	/**
	 * 勤怠承認機能状況取得(M_CODE)
	 * @return	boolean 	勤怠承認機能の有効無効
	 * @throws Exception 
	 */
	protected boolean isAttendanceApprovalFunction() throws Exception {
		return PartManager.mospcode(partInfo()).isAttendanceApprovalFunction();
	}

	/**
	 * パスワード有効期限日数
	 * @return	int		パスワード有効期限日数
	 * @throws Exception
	 */
	protected int getPasswordTerm() throws Exception {
		return PartManager.mospcode(partInfo()).getPasswordTerm();
	}

	/**
	 * フィールド名称内のデータ分解取得
	 *  0 : ファイルID
	 *  1 : 管理番号
	 *  2 : フィールドID
	 *  3 : フィールド名称
	 */
	protected String getEFnameItem(String csvString, int i) {
		return VariousPart.getEFnameItem(csvString, i);
	}

	/**
	 * 該当フラグ配列
	 * @return 該当フラグ配列
	 */
	protected String[][] getCorrespondFlagArray() {
		return VariousPart.getCorrespondFlagArray();
	}

	/**
	 * 和暦元号配列
	 * @return	和暦元号配列
	 * @throws Exception
	 */
	protected String[][] getJPCalendarGengo() throws Exception {
		return PartManager.cmcode(partInfo()).getJPCalendarGengo();
	}

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

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

	/**
	 * 役職手当区分プルダウンリスト（有無＋給与情報単価＋固定単価）
	 * @return 役職手当区分配列
	 */
	protected String[][] getPositionAllowanceType3() {
		return VariousPart.getPositionAllowanceType3();
	}

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

	/**
	 * 対象年から対象年度を取得
	 * @param year		対象年
	 * @param month		対象月
	 * @param startmonth	年度開始月
	 * @return	対象年度
	 * @throws Exception
	 */
	protected int getTargetFiscalYear(int year, int month, int startmonth) throws Exception {
		return VariousPart.getTargetFiscalYear(year, month, startmonth);
	}

	/**
	 * 対象年度から対象年を取得
	 * @param fiscalyear		対象年度
	 * @param month				対象月
	 * @param startmonth		年度開始月
	 * @return	対象年
	 */
	protected int getTargetYear(int fiscalyear, int month, int startmonth) {
		return VariousPart.getTargetYear(fiscalyear, month, startmonth);
	}

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

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

	/**
	 * 和暦表示設定
	 * @param targetDate	対象年月日
	 * @return	和暦表示
	 * @throws MospException
	 * @throws Exception
	 */
	protected String getJapaneseDate(Date targetDate) throws MospException, Exception {
		return PartManager.jpdate(partInfo()).getJapaneseDate(targetDate);
	}

	/**
	 * 和暦表示設定
	 * @param targetDate	対象年月日(yyyy-mm-dd)
	 * @return	和暦表示
	 * @throws MospException
	 * @throws Exception
	 */
	protected String getJapaneseDate(String targetDate) throws MospException, Exception {
		return PartManager.jpdate(partInfo()).getJapaneseDate(DatePart.convHyphenDateToDate(targetDate));
	}

	/**
	 * 承認ステータスコードリスト取得
	 * @return 承認ステータスコードリスト配列
	 * @see VariousPart#getApprovalStatusCodeArray()
	 */
	protected String[] getApprovalStatusCodeArray() {
		return VariousPart.getApprovalStatusCodeArray();
	}

	/* (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() {
		return VariousPart.getManageCode();
	}

	/**
	 * 閲覧権限プルダウンリスト
	 * @return	String[][]	出力範囲配列
	 */
	protected String[][] getManageArray() {
		return VariousPart.getManageArray();
	}

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

	/*Part関連*/

	/**
	 * 初期化済みPartクラスインスタンス取得
	 * @param partClassName		対象Partクラス
	 * @return	対象初期化済みPartクラスインスタンス
	 * @throws Exception
	 */
	protected BasePart getPart(String partClassName) throws Exception {
		return PartManager.getPreparedPart(partClassName, partInfo());
	}

}
