package jp.mosp.common.action;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;


import jp.mosp.common.CommonConst;
import jp.mosp.common.MosPAction;
import jp.mosp.common.MosPMenuConst;
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.CmComponentDao;
import jp.mosp.common.dto.CmAuthorityDto;
import jp.mosp.common.dto.CmComponentDto;
import jp.mosp.common.part.PartManager;
import jp.mosp.common.part.VariousPart;
import jp.mosp.common.vo.MosPMenuArrangeVo;

public abstract class MosPMenuArrangeAction extends MosPAction {

	protected static final String CONF_ID_EMPLOYEE 	= CommonConst.CONF_ID_EMPLOYEE;
	protected static final String CONF_ID_MANAGER 	= CommonConst.CONF_ID_MANAGER;
	protected static final String CONF_ID_HUMAN 		= CommonConst.CONF_ID_HUMAN;
	protected static final String CONF_ID_PAYROLL 	= CommonConst.CONF_ID_PAYROLL;

	/*メニュー番号*/
	protected static final int AUTH_EMPLOYEE_MENU 	= 0;
	protected static final int AUTH_MANAGER_MENU 		= 1;
	protected static final int AUTH_HUMAN_MENU 		= 2;
	protected static final int AUTH_PAYROLL_MENU 		= 3;
	protected static final int AUTH_CALCULATE_MENU 	= 4;
	protected static final int AUTH_SYSTEM_MENU 		= 5;

	/*DAO*/
	protected CmComponentDao cmCompoDao;
	protected CmAuthorityDao cmAuthDao;

	/*DTO*/
	protected CmComponentDto cmCompoDto;

	/**
	 * メニュー構成用DAOの準備
	 * @throws Exception 
	 * @throws MospException 
	 */
	protected void prepareCmComponentDao() throws MospException, Exception {
		if (cmCompoDao != null) {
			return;
		}
		// DAOの準備
		cmCompoDao = PartManager.component(partInfo()).getCmComponentDao();
	}

	/**
	 * 権限用DAOの準備
	 * @throws Exception 
	 * @throws MospException 
	 */
	protected void prepareCmAuthorityDao() throws MospException, Exception {
		if (cmAuthDao != null) {
			return;
		}
		// DAOの準備
		cmAuthDao = PartManager.authority(partInfo()).getCmAuthorityDao();
	}

	/**
	 * 分類別権限区分取得(CM_COMPONENT)
	 * @param division 分類
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * @throws Exception
	 */
	protected String[][] getDivisionAuthArray(String division) throws Exception {
		return PartManager.component(partInfo()).getDivisionAuthArray(division);
	}

	/**
	 * 分類別権限区分取得(CM_COMPONENT)
	 * @param division 分類
	 * @return コード配列[][]<br>
	 * 			[0]tcode<br>
	 * 			[1]tname<br>
	 * @throws Exception
	 */
	protected String[][] getDivisionAuthAllArray(String division) throws Exception {
		return PartManager.component(partInfo()).getDivisionAuthAllArray(division);
	}

	/**
	 * デフォルトメニュー権限リスト作成(Authority)
	 * @return map
	 */
	protected Map<String, CmAuthorityDto> getDefaultAuthMap() {
		Map<String, CmAuthorityDto> map = new HashMap<String, CmAuthorityDto>();
		for (int i = 0; i < getDefaultAuthArray().length; i++) {
			CmAuthorityDto dto = getDefaultAuthDto(i);
			map.put(dto.getAuthCode(), dto);
		}
		return map;
	}

	/**
	 * デフォルトの権限情報取得
	 * @return	デフォルトの権限情報
	 */
	protected CmAuthorityDto getDefaultAuthDto() {
		return getDefaultAuthMap().get(user.getMospAuthority());
	}

	/**
	 * @param title
	 * @param command
	 * @return
	 */
	protected String[] getMenuUnit(String title, String command) {
		return util.createArray(title, command);
	}

	/**
	 * デフォルトDTO作成（CmComponent）
	 * <p>メニュー番号</p>
	 * 0、勤怠入力
	 * 1、勤怠管理
	 * 2、人事管理
	 * 3、給与管理
	 * 4、計算権限
	 * @param menu			メニュー番号
	 * @return dto			
	 * @throws Exception
	 */
	protected CmComponentDto getDefaultCompoDto(int i) {
		CmComponentDto dto = new CmComponentDto();
		dto.setDivision		(getDefaultCompArray()[i][0]);
		dto.setCompCode		(getDefaultCompArray()[i][0]);
		dto.setCompName		(getDefaultCompArray()[i][1]);
		dto.setManage		(Integer.parseInt(getDefaultCompArray()[i][2]));
		dto.setComponent	(getDefaultCompArray()[i][3]);
		return dto;
	}

	/**
	 * デフォルトDTO作成（CmAuthority）
	 * @return dto			
	 * @throws Exception
	 */
	private CmAuthorityDto getDefaultAuthDto(int i) {
		CmAuthorityDto dto = new CmAuthorityDto();
		dto.setAuthCode(getDefaultAuthArray()[i][0]);
		dto.setAuthName(getDefaultAuthArray()[i][1]);
		dto.setEmployee(getDefaultAuthArray()[i][2]);
		dto.setManager(getDefaultAuthArray()[i][3]);
		dto.setPayroll(getDefaultAuthArray()[i][4]);
		dto.setHuman(getDefaultAuthArray()[i][5]);
		return dto;
	}

	/**
	 * 各デフォルト基本権限の配列作成 {division/code,name,manage,component}
	 * @return array
	 */
	private String[][] getDefaultCompArray() {
		String[][] array = {
				{ CommonConst.CONF_ID_EMPLOYEE	, CommonConst.NAM_AUTH_EMPLOYEE	+ CommonConst.NAM_NEW_DATA_M_KIHON , "0" , convAryToComponent(getEmployeeCmdArray())		},
				{ CommonConst.CONF_ID_MANAGER  	, CommonConst.NAM_AUTH_MANAGER	+ CommonConst.NAM_NEW_DATA_M_KIHON , "1" , convAryToComponent(getManagerCmdArray())			},
				{ CommonConst.CONF_ID_HUMAN 	, CommonConst.NAM_AUTH_HUMAN 	+ CommonConst.NAM_NEW_DATA_M_KIHON , "2" , convAryToComponent(getHumanCmdArray())			},
				{ CommonConst.CONF_ID_PAYROLL 	, CommonConst.NAM_AUTH_PAYROLL 	+ CommonConst.NAM_NEW_DATA_M_KIHON , "2" , convAryToComponent(getPayrollRestrictCalcArray())},
				{ CommonConst.CONF_ID_CALCULATE , CommonConst.NAM_AUTH_CALCULATE+ CommonConst.NAM_NEW_DATA_M_KIHON , "2" , convAryToComponent(getPayrollCmdArray())			}
		};
		return array;
	}

	/**
	 * デフォルト権限コードの配列作成 {code,name,Employee,Manager,Payroll,Human}
	 * @return array
	 */
	private String[][] getDefaultAuthArray() {
		String[][] array = {
				{ CommonConst.AUTH_DEFAULT_USER 	, CommonConst.NAM_AUTH_EMPLOYEE 	, CommonConst.CONF_ID_EMPLOYEE ,""  							,""  							,""  						},
				{ CommonConst.AUTHORITY_MANAGER 	, CommonConst.NAM_AUTH_MANAGER  	, CommonConst.CONF_ID_EMPLOYEE ,CommonConst.CONF_ID_MANAGER 	,""  							,""  						},
				{ CommonConst.AUTHORITY_PAYROLL 	, CommonConst.NAM_AUTH_PAYROLL  	, CommonConst.CONF_ID_EMPLOYEE ,""  							,CommonConst.CONF_ID_PAYROLL 	,""  						},
				{ CommonConst.AUTHORITY_HUMAN 		, CommonConst.NAM_AUTH_HUMAN  		, CommonConst.CONF_ID_EMPLOYEE ,""  							,""  							,CommonConst.CONF_ID_HUMAN 	},
				{ CommonConst.AUTHORITY_CALCULATE	, CommonConst.NAM_AUTH_CALCULATE 	, CommonConst.CONF_ID_EMPLOYEE ,""  							,CommonConst.CONF_ID_CALCULATE  ,"" 						},
				{ CommonConst.AUTHORITY_SENIORS 	, CommonConst.NAM_AUTH_SENIORS  	, CommonConst.CONF_ID_EMPLOYEE ,CommonConst.CONF_ID_MANAGER 	,CommonConst.CONF_ID_PAYROLL 	,CommonConst.CONF_ID_HUMAN 	}
		};
		return array;
	}

	/**
	 * 二次配列データ取り出しメソッド
	 * @param array		対象配列
	 * @return	string	結合文字列
	 */
	protected String convAryToComponent(String[][] array) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < array.length; i++) {
			sb.append(array[i][0]);
			sb.append(CommonConst.STR_UNDER_SEPARATOR);
		}			
		return sb.toString();
	}

	/**
	 * 権限別DTO取得
	 * @return 権限DTO
	 * @throws Exception
	 */
	protected CmAuthorityDto getUserAuthDto() throws Exception {
		// 権限用DAOの準備
		prepareCmAuthorityDao();
		return cmAuthDao.findForAuth(user.getMospAuthority());
	}

	/**
	 * メニュー番号によるコマンド番号配列生成
	 * @param menuno
	 * @return
	 */
	protected String[][] getMenuCmdArray(int menuno) {
		String[][] array = {{"", ""}};
		switch (menuno) {
		case AUTH_EMPLOYEE_MENU:
			array = getEmployeeCmdArray();
			break;
		case AUTH_MANAGER_MENU:
			array = getManagerCmdArray();
			break;
		case AUTH_HUMAN_MENU:
			array = getHumanCmdArray();
			break;
		case AUTH_PAYROLL_MENU:
		case AUTH_CALCULATE_MENU:
			array = getPayrollCmdArray();
			break;
		case AUTH_SYSTEM_MENU:
			array = getSystemCmdArray();
			break;
		default:
			break;
		}
		return array;
	}

	/**
	 * メニュー構成DTO取得
	 * @param authDto		対象DTO
	 * @param menuno		メニュー番号
	 * @return	メニュー構成DTO
	 * @throws Exception
	 */
	protected CmComponentDto getMenuComponent(CmAuthorityDto authDto, int menuno) throws Exception {
		CmComponentDto dto = null;
		String findKey = "";
		if (authDto != null) {
			switch (menuno) {
			case AUTH_EMPLOYEE_MENU:
				findKey = authDto.getEmployee();
				break;
			case AUTH_MANAGER_MENU:
				findKey = authDto.getManager();
				break;
			case AUTH_HUMAN_MENU:
				findKey = authDto.getHuman();
				break;
			case AUTH_PAYROLL_MENU:
			case AUTH_CALCULATE_MENU:
				findKey = authDto.getPayroll();
				break;
			default:
				break;
			}
			// メニュー構成用DAOの準備
			dto = PartManager.component(partInfo()).findForKey(findKey);
		}
		return dto;
	}

	/**
	 * メニュー構成取得
	 * @param dto	対象DTO
	 * @return	メニューコマンド文字列
	 */
	protected String getComponent(CmComponentDto dto) {
		if (VariousPart.chkExistDto(dto)) {
			return dto.getComponent();
		}
		return "";
	}

	/**
	 * メニュー構成取得
	 * @param dto	対象DTO
	 * @param menuno	対象メニュー番号
	 * @return	メニューコマンド文字列
	 * @throws Exception
	 */
	protected String getComponent(CmAuthorityDto dto, int menuno) throws Exception {
		if (VariousPart.chkExistDto(dto)) {
			return getComponent(getMenuComponent(dto, menuno));
		}
		return "";
	}

	/**
	 * 従業員コマンドDTO取得
	 * @param CmAuthorityDto 
	 * @return DTO
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String getEmployeeComponent(CmAuthorityDto cmAuthorityDto) throws Exception {
		CmComponentDto dto = getMenuComponent(cmAuthorityDto, AUTH_EMPLOYEE_MENU);
		// デフォルトコードの設定
		if (!VariousPart.chkExistDto(dto)) {
			dto = getDefaultCompoDto(AUTH_EMPLOYEE_MENU);	
		}
		return dto.getComponent();
	}

	/**
	 * マネージャーコマンドDTO取得
	 * @param CmAuthorityDto 
	 * @return DTO
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String getManagerComponent(CmAuthorityDto cmAuthorityDto) throws Exception {
		CmComponentDto dto = getMenuComponent(cmAuthorityDto, AUTH_MANAGER_MENU);
		// デフォルトコードの設定
		if (!VariousPart.chkExistDto(dto)) {
			dto = getDefaultCompoDto(AUTH_MANAGER_MENU);
		}
		return dto.getComponent();
	}

	/**
	 * 給与コマンドDTO取得
	 * @param CmAuthorityDto 
	 * @return DTO
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String getPayrollComponent(CmAuthorityDto cmAuthorityDto) throws Exception {
		CmComponentDto dto = getMenuComponent(cmAuthorityDto, AUTH_PAYROLL_MENU);	
		// デフォルトコードの設定
		if (!VariousPart.chkExistDto(dto)) {		
			if (user.getMospAuthority().equals(CommonConst.AUTHORITY_CALCULATE)) {
				dto = getDefaultCompoDto(AUTH_CALCULATE_MENU);
			} else {
				dto = getDefaultCompoDto(AUTH_PAYROLL_MENU);
			}
		}
		// 勤怠計算ボタン表示設定
		return getCalcButton(dto);
	}

	/**
	 * 勤怠計算ボタン表示メソッド
	 * @param dto		対象DTO
	 * @param isMenu	初期メニュー可否
	 * @return　結合文字列
	 */
	protected String getCalcButton(CmComponentDto dto, boolean isMenu) {
		return getMenuButton(dto, isMenu, getCalcCmdArray());
	}

	/**
	 * 勤怠計算ボタン表示メソッド
	 * @param array		対象配列
	 * @return	string	結合文字列
	 */
	protected String getCalcButton(CmComponentDto dto) {
		String[] aryCommand = util.divideByComma(dto.getComponent());
		int count = 0;
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < aryCommand.length; i++) {
			for (int k = 0; k < getCalcCmdArray().length; k++) {
				if (aryCommand[i].equals(getCalcCmdArray()[k])) {
					count++;
					aryCommand[i] = CommonConst.NAM_COMMON_STRING_INITIAL_VALUE;
				}
			}
		}
		if (count > 0) {
			sb.append(getCalcCmdArray()[0]);
			sb.append(CommonConst.STR_UNDER_SEPARATOR);	
		}
		for (int i = 0; i < aryCommand.length; i++) {
			if (aryCommand[i].length() != 0) {
				sb.append(aryCommand[i]);
				sb.append(CommonConst.STR_UNDER_SEPARATOR);	
			}
		}
		return sb.toString();
	}
	
	/**
	 * 勤怠計算ボタン表示メソッド
	 * @param array		対象配列
	 * @return	string	結合文字列
	 */
	protected String getMenuButton(CmComponentDto dto, boolean isMenu, String[] aryMenuCommand) {
		String[] aryCommand = util.divideByComma(dto.getComponent());
		StringBuffer sb = new StringBuffer();
		List<String> list = util.arrayToList(aryCommand);
		List<String> listMenu = util.arrayToList(aryMenuCommand);
		String menuCmd = aryMenuCommand[0];
		while (list.contains(menuCmd)) {
			list.remove(menuCmd);
		}
		if (isMenu) {
			list.add(menuCmd);
		}
		if (list.containsAll(listMenu) && isMenu) {
			sb.append(menuCmd);
			sb.append(CommonConst.STR_UNDER_SEPARATOR);
		}
		for (Iterator iter = list.iterator(); iter.hasNext();) {
			String select = (String) iter.next();
			if (isMenu && !listMenu.contains(select)) {
				sb.append(select);
				sb.append(CommonConst.STR_UNDER_SEPARATOR);	
			}
			if (!isMenu && listMenu.contains(select)) {
				sb.append(select);
				sb.append(CommonConst.STR_UNDER_SEPARATOR);	
			}
		}
		return sb.toString();
	}

	/**
	 * 人事コマンドDTO取得
	 * @param CmAuthorityDto 
	 * @return DTO
	 * @throws SQLException
	 * @throws NoSuchFieldException
	 * @throws IllegalAccessException
	 */
	protected String getHumanComponent(CmAuthorityDto cmAuthorityDto) throws Exception {
		CmComponentDto dto = getMenuComponent(cmAuthorityDto, AUTH_HUMAN_MENU);
		// デフォルトコードの設定
		if (!VariousPart.chkExistDto(dto)) {
			dto = getDefaultCompoDto(AUTH_HUMAN_MENU);
		}
		return dto.getComponent();
	}

	/**
	 * フィールド用配列設定
	 * @param component コマンド設定
	 */
	protected List<String[]> getMenuList(String component) {
		String[] aryCommand = util.divideByComma(component);
		String[] aryMenu = new String[aryCommand.length];
		String[][] aryAllCommand = combineAllCmdArray();
		for (int i = 0 ; i < aryCommand.length ; i++) {
			aryMenu[i] = "";
			String cmdNo = aryCommand[i];
			String cmdName = util.getCodeName(cmdNo, aryAllCommand);
			if (!cmdNo.equals(cmdName)) {
				aryMenu[i] = cmdName;
			}
		}
		List<String[]> list = new ArrayList<String[]>();
		list.add(aryCommand);
		list.add(aryMenu);
		return list;
	}

	/**
	 * 初期処理
	 * @param vo			対象VO
	 * @throws Exception
	 */
	protected void initCardAction(MosPMenuArrangeVo vo) throws Exception {
		vo.initVo(cfg, msg, cmd, aspUser, user);
		// VO及びフォワード先URLの設定
		setVo(vo);
		setUrl(vo.getRetUrl());
		vo.setCardParams(request);
		// DAOの準備
		prepareCmComponentDao();
		// DTOの取得
		Object obj = session.getAttribute(MospConst.ATT_DTO);
		cmCompoDto = obj instanceof CmComponentDto ? (CmComponentDto)obj : null;
		vo.aryPltManage = getManageArray();
	}

	/**
	 * 初期処理
	 * @param vo		対象VO
	 */
	protected void initListAction(MosPMenuArrangeVo vo) {
		vo.clearMessage();
		vo.clearErrField();
		vo.initVo(cfg, msg, cmd, aspUser, user);
		// VO及びフォワード先URLの設定
		setVo(vo);
		setUrl(vo.getRetUrl());
		session.setAttribute(MospConst.ATT_FORMER_VO, vo);
		vo.aryPltManage = getManageArray();
	}

	/**
	 * メニューアレンジCardVo情報設定
	 * @param targetCmdArray		対象コマンド配列
	 * @param division				対象メニュー
	 * @param vo					対象VO
	 */
	protected void setCardVoInfo(
			String[][] targetCmdArray,
			String division,
			MosPMenuArrangeVo vo
	) {
		// 項目設定
		vo.aryPltCmdItem = targetCmdArray;
		vo.setHidDivision(division);
	}

	/**
	 * メニューアレンジListVo情報設定
	 * @param targetCmdArray		対象コマンド配列
	 * @param division				対象メニュー
	 * @param vo					対象VO
	 */
	protected void setListVoInfo(
			String[][] targetCmdArray,
			String division,
			MosPMenuArrangeVo vo
	) {
		vo.aryPltCmdItem = targetCmdArray;
		vo.setHidDivision(division);
	}

	/**
	 * 表示
	 * @param vo	対象VO
	 */
	protected void show(MosPMenuArrangeVo vo) {
		vo.arySelectedCmdItem = new String[0][2];
		vo.setMode(MosPMenuArrangeVo.MODE_INSERT);
		// セッションにDTOをセット
		session.setAttribute(MospConst.ATT_DTO, cmCompoDto);
	}

	/**
	 * 選択
	 * @param vo			対象VO
	 * @throws Exception
	 */
	protected void select(MosPMenuArrangeVo vo) throws Exception {
		cmCompoDto = PartManager.component(partInfo()).findForDto(key1, vo.getHidDivision());
		chkExist(cmCompoDto);
		vo.setFields(cmCompoDto);
		// モード設定
		vo.setMode(MosPMenuArrangeVo.MODE_UPDATE);
		// セッションにDTOをセット
		session.setAttribute(MospConst.ATT_DTO, cmCompoDto);
	}

	/**
	 * 検索
	 * @param vo			対象VO
	 * @throws Exception
	 */
	protected void search(MosPMenuArrangeVo vo) throws Exception {
		vo.setListParams(request);
		searchList(vo);
		vo.setIsAscending(true);
		vo.initListInfo();
		// 検索履歴をありにセット
		vo.setSearchmode(MosPMenuArrangeVo.SEARCH_ON);
	}

	/**
	 * 再検索
	 * @param vo			対象VO
	 * @throws Exception
	 */
	protected void research(MosPMenuArrangeVo vo) throws Exception {
		if (vo.getSearchmode() == MosPMenuArrangeVo.SEARCH_ON) {
			session.removeAttribute(MospConst.ATT_DTO);
			searchList(vo);
			vo.setPageButton();
			sortList(vo);
		}
	}

	/**
	 * リスト検索
	 * @param vo 対象Voインスタンス
	 * @throws Exception
	 */
	private void searchList(MosPMenuArrangeVo vo) throws Exception {
		// 検索
		prepareCmComponentDao();
		vo.setFields(cmCompoDao.findForCondition(
				vo.getTxtCompCode(),
				vo.getHidDivision(),
				vo.getTxtCompName(),
				vo.getPltManage(),
				vo.getPltDelete())								
		);
		// 対象が無かった場合のメッセージ設定
		if (vo.getEscAryCompCode().length == 0) {
			vo.addErrMessage(MospUtility.getMessage(msg, MospConst.MSG_NO_DATA, ""));
		}
	}

	/**
	 * ソート
	 * @param key ソートキー
	 * @param vo ソート対象Listを含むVO
	 * @throws MospException
	 */
	protected void sortList(String key, MosPMenuArrangeVo vo) throws MospException {
		vo.sortList(key, getComparator(key, vo));
		vo.setFields(vo.getList());
	}

	/**
	 * ソート(VO内のキー情報でソート)
	 * @param vo ソート対象Listを含むVO
	 * @throws MospException
	 */
	protected void sortList(MosPMenuArrangeVo vo) throws MospException {
		vo.sortList(getComparator(vo.getFormerKey(), vo));
		vo.setFields(vo.getList());
	}

	/**
	 * 比較クラス取得
	 * @param key ソートキー
	 * @param vo ソート対象Listを含むVO
	 * @throws MospException
	 */
	private Comparator<Object> getComparator(String key, MosPMenuArrangeVo vo) throws MospException {
		Comparator<Object> comp = null;
		if (key.equals(vo.KEY_COMP_CODE)) {
			comp = new CmComponentCode();
		} else if (key.equals(vo.KEY_COMP_NAME)) {
			comp = new CmComponentName();
		} else if (key.equals(vo.KEY_MANAGE)) {
			comp = new CmComponentManage();
		} else if (key.equals(vo.KEY_COMPONENT)) {
			comp = new CmComponent();
		} else if (key.equals(vo.KEY_DELETE)) {
			comp = new CompOutPutDelete();
		} else {
			throw new MospException(MospConst.EX_SORTKEY_INVALID);
		}
		return comp;
	}

	/**
	 * 対象コードによる比較クラス
	 */
	protected static class CmComponentCode implements Comparator<Object>, Serializable {
		private static final long serialVersionUID = -1478623163300375391L;
		public int compare(Object obj1, Object obj2) {
			CmComponentDto dto1 = (CmComponentDto)obj1;
			CmComponentDto dto2 = (CmComponentDto)obj2;
			return dto1.getCompCode().compareTo(dto2.getCompCode());
		}
	}

	/**
	 * 対象名称による比較クラス
	 */
	protected static class CmComponentName implements Comparator<Object>, Serializable {
		private static final long serialVersionUID = -2713846748281480319L;
		public int compare(Object obj1, Object obj2) {
			CmComponentDto dto1 = (CmComponentDto)obj1;
			CmComponentDto dto2 = (CmComponentDto)obj2;
			return dto1.getCompName().compareTo(dto2.getCompName());
		}
	}

	/**
	 * 閲覧権限による比較クラス
	 */
	protected static class CmComponentManage implements Comparator<Object>, Serializable {
		private static final long serialVersionUID = -1445454210063675079L;
		public int compare(Object obj1, Object obj2) {
			CmComponentDto dto1 = (CmComponentDto)obj1;
			CmComponentDto dto2 = (CmComponentDto)obj2;
			return String.valueOf(dto1.getManage()).compareTo(String.valueOf(dto2.getManage()));
		}
	}

	/**
	 * 閲覧可能機能による比較クラス
	 */
	protected static class CmComponent implements Comparator<Object>, Serializable {
		private static final long serialVersionUID = 4168257683510439452L;
		public int compare(Object obj1, Object obj2) {
			CmComponentDto dto1 = (CmComponentDto)obj1;
			CmComponentDto dto2 = (CmComponentDto)obj2;
			return String.valueOf(dto1.getComponent()).compareTo(String.valueOf(dto2.getComponent()));
		}
	}

	/**
	 * 削除フラグによる比較クラス
	 */
	protected static class CompOutPutDelete implements Comparator<Object>, Serializable {
		private static final long serialVersionUID = -1608954783023296757L;
		public int compare(Object obj1, Object obj2) {
			CmComponentDto dto1 = (CmComponentDto)obj1;
			CmComponentDto dto2 = (CmComponentDto)obj2;
			return dto2.getDeleteFlag() - dto1.getDeleteFlag();
		}
	}

	/**
	 * 選択出力項目配列
	 * @param array		対象array
	 * @return	arySelectedItem
	 */
	protected String[][] setSelectedItemArray(String[] array) throws Exception {
		String[][] arySelectedItem = new String[1][2];
		arySelectedItem[0][0] = "";
		arySelectedItem[0][1] = "";
		if (chkExistObject(array)) {
			arySelectedItem = new String[array.length][2];
			for (int i = 0; i < arySelectedItem.length; i++) {
				arySelectedItem[i][0] = String.valueOf(i);
				arySelectedItem[i][1] = array[i];
			}
		}
		return arySelectedItem;
	}

	/**
	 * データ挿入
	 * @param vo 対象VO
	 * @throws Exception
	 * @return データ挿入対象DTO
	 * @throws Exception
	 */
	protected void insert(MosPMenuArrangeVo vo) throws Exception {
		// DTOの準備
		CmComponentDto dto = new CmComponentDto();
		vo.setPltDelete(String.valueOf(MospConst.DELETE_FLAG_OFF));
		// パラメータの妥当性確認
		vo.validate();
		// DAOの準備
		prepareCmComponentDao();
		cmCompoDao.initDao(cfg, cmd, aspUser, user, conn);
		chkDuplicate(cmCompoDao.findForKey(vo.getEscTxtCompCode()), vo);
		// DTOの準備
		vo.setDtoFields(dto);
		// データの更新
		cmCompoDao.insert(dto);
		// DTOの再取得
		CmComponentDto retDto = cmCompoDao.findForDto(dto.getCompCode(), dto.getDivision());
		chkInsert(retDto);
		// コミット
		commit();
		// モード設定
		vo.setMode(MosPMenuArrangeVo.MODE_UPDATE);
		// メッセージ設定
		vo.setMessage(MospUtility.getMessage(msg, MospConst.MSG_INSERT, ""));
		// セッションにDTOをセット
		session.setAttribute(MospConst.ATT_DTO, retDto);		
	}

	/**
	 * データ更新
	 * @param vo 対象VO
	 * @return データ挿入対象DTO
	 * @throws Exception
	 */
	protected void update(MosPMenuArrangeVo vo) throws Exception {
		// パラメータの妥当性確認
		vo.validate();
		// DAOの準備
		prepareCmComponentDao();
		// 排他確認
		chkExclusive(cmCompoDto, cmCompoDao.findForUpdate(vo.getEscTxtCompCode()), vo);
		// DTOの準備
		vo.setDtoFields(cmCompoDto);
		// データの更新
		cmCompoDao.update(cmCompoDto);
		// DTOの再取得
		CmComponentDto retDto = cmCompoDao.findForDto(cmCompoDto.getCompCode(), cmCompoDto.getDivision());
		chkUpdate(retDto);
		// コミット
		commit();
		// モード設定
		vo.setMode(MosPMenuArrangeVo.MODE_UPDATE);
		// メッセージ設定
		vo.setMessage(MospUtility.getMessage(msg, MospConst.MSG_UPDATE, ""));
		// セッションにDTOをセット
		session.setAttribute(MospConst.ATT_DTO, retDto);			
	}	

	// アクセサメソッド
	/**
	 * 従業員用コマンドの配列
	 * @return array
	 */
	protected String[][] getEmployeeCmdArray() {
		return MosPMenuConst.getEmployeeCmdArray();
	}

	/**
	 * マネージャー用コマンドの配列
	 * @return array
	 */
	protected String[][] getManagerCmdArray() {
		return MosPMenuConst.getManagerCmdArray();
	}

	/**
	 * 給与用コマンドの配列
	 * @return array
	 */
	protected String[][] getPayrollCmdArray() {
		return MosPMenuConst.getPayrollCmdArray();
	}

	/**
	 * 人事用コマンドの配列
	 * @return array
	 */
	protected String[][] getHumanCmdArray() {
		return MosPMenuConst.getHumanCmdArray();
	}

	/**
	 * システム用コマンドの配列
	 * @return array
	 */
	protected String[][] getSystemCmdArray() {
		return MosPMenuConst.getSystemCmdArray();
	}

	/**
	 * 勤怠計算用コマンドの配列
	 * @return array
	 */
	protected String[] getCalcCmdArray() {
		return MosPMenuConst.getCalcCmdArray();
	}

	/**
	 * 給与(計算機能制限つき)用コマンドの配列作成 cmd,name
	 * @return array
	 */
	private String[][] getPayrollRestrictCalcArray() {
		return MosPMenuConst.getPayrollRestrictCalcArray();
	}

	/**
	 * 給与登録画面表示用コマンドの配列作成 cmd,name
	 * @return array
	 */
	protected String[][] getViewPayrollCmdArray() {
		return MosPMenuConst.getViewPayrollCmdArray();
	}

	/**
	 * コマンド配列の結合
	 * @return	String[][]	結合配列
	 */
	protected String[][] combineAllCmdArray() {
		return util.combineArray(getAllCmdArrayList());
	}

	/**
	 * 全コマンドリスト生成
	 * @return
	 */
	protected List<String[][]> getAllCmdArrayList() {
		List<String[][]> list = new ArrayList<String[][]>();
		list.add(getEmployeeCmdArray());
		list.add(getManagerCmdArray());
		list.add(getHumanCmdArray());
		list.add(getPayrollCmdArray());
		list.add(getSystemCmdArray());	
		return list;
	}

}