/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKUejbCheckHktg
*   ソースファイル名：JKUejbCheckHktg.java
*   作成者          ：富士通
*   日付            ：2011年12月20日
*＜機能概要＞
*   引継工事案件チェック処理部品です。
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2011/12/20   FJ          新規作成
*
**********************************************************************/

package eo.ejb.common;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fujitsu.futurity.model.base.CAANException;
import com.fujitsu.futurity.model.base.CAANMsg;

import eo.common.constant.JKUStrConst;
import eo.ejb.cbm.entity.KU0011ETMsg;
import eo.ejb.cbm.entity.KU0021ETMsg;
import eo.ejb.cbm.entity.KU0051ETMsg;
import eo.ejb.cbm.entity.KU0061ETMsg;
import eo.ejb.cbm.entity.KU0071ETMsg;
import eo.ejb.cbm.entity.KU0081ETMsg;
import eo.ejb.common.db.JKUejbKU0011SecProc;
import eo.ejb.common.db.JKUejbKU0021SecProc;
import eo.ejb.common.db.JKUejbKU0051SecProc;
import eo.ejb.common.db.JKUejbKU0061SecProc;
import eo.ejb.common.db.JKUejbKU0071SecProc;
import eo.ejb.common.db.JKUejbKU0081SecProc;

/**
 * 引継工事案件チェック処理。<p>
 * 工事案件の引継元、引継先を原因としたエラー処理を行う
 * <BR>
 * @author 富士通
 */
public class JKUejbCheckHktg
{
	
	/**
	 * チェック結果
	 */
	
	/** エラー無し */
	private static final int CHECK_OK = 0;
	/** 整合性エラー */
	private static final int CHECK_ERR_SEIGOSEI = -1;
	/** エラーパターン合致エラー */
	private static final int CHECK_ERR_PATTERN = 1;
	
	/**
	 * 引継パターンチェック用定数
	 */
	
	/** これから登録される工事案件 */
	private static final String HKTG_MI_TOROKU = "hktg_mi_toroku";
	/** スキーマ整合性エラー */
	private static final String HKTG_SCHEMA_ERR = "hktg_schema_err";
	

	
	/**
	 * 現行サービス契約マップキー
	 */
	
	/** 工事案件番号 */
	private static final String MAP_KOJIAK_NO = "map_kojiak_no";
	/** サービス契約_工事案件適用終了年月日 */
	private static final String MAP_SVKEI_KJAK_TENDYMD = "map_svkei_kjak_tendymd";
	
	/**
	 * 整合性チェック用配列定数
	 */
	private static final boolean[][] SEIGOSEI_RESULT_ARRAY = new boolean[][] {
	//		0:これから登録			1:引継実行中の			2:引継が完了			3:引継先が存在			4:解約された
	//			される工事案件				工事案件			した工事案件			しない工事案件			工事案件
		{	true,					false,					false,					false,					false},		//	0:これから登録される工事案件
		{	false,					true,					true,					true,					true},		//	1:引継元が存在しない工事案件
		{	false,					false,					false,					true,					false},		//	2:HTから引継中の工事案件
		{	false,					true,					true,					true,					true},		//	3:HTから引継完了の工事案件
		{	false,					false,					false,					true,					false},		//	4:IOから引継中の工事案件
		{	false,					true,					true,					true,					true}		//	5:IOから引継完了の工事案件
	};
	
	/**
	 * 追加元サービス契約番号取得サブスキーマパターン
	 */
	/** 工事案件＜eo光ネット＞ */
	private static final String ADD_MOTO_SUB_PTN_HT = "add_moto_sub_ptn_ht";
	/** 工事案件＜eoオフィス＞ */
	private static final String ADD_MOTO_SUB_PTN_IO = "add_moto_sub_ptn_io";
	/** 工事案件＜eo光ネットマンション＞ */
	private static final String ADD_MOTO_SUB_PTN_MT = "add_moto_sub_ptn_MT";
	/**
	 * 工事案件引継パターン判別処理
	 * @param svcKeiNo	サービス契約番号
	 * @param errorPatternArray	エラーパターン配列
	 * @param hojinFlg	法人フラグ
	 * @return	処理結果 (0:エラー無し、-1:整合性エラー、1:エラーパターン合致エラー)
	 * @throws CAANException
	 */
	public static int checkHktgPattern(String svcKeiNo, String[] errorPatternArray, boolean hojinFlg) throws CAANException
	{
		
		// ---現行サービス契約リストを取得する
		
		List<Map<String, String>> svcKeiMapList = null;
		
		if (false == hojinFlg)
		{
			svcKeiMapList = selectKU0081Map(svcKeiNo);
		}
		else
		{
			svcKeiMapList = selectKU0071Map(svcKeiNo);
		}
		
		// ---引継元存在判別処理を実行する
		
		String hktgMotoPattern = checkHktgMotoPattern(svcKeiMapList, hojinFlg);
		
		// ---引継先存在判別処理を実行する
		
		String hktgSakiPattern = checkHktgSakiPattern(svcKeiNo, svcKeiMapList);
		
		// ---引継先整合性チェックを実行する
		
		if (false == checkHktgSeigosei(hktgMotoPattern, hktgSakiPattern))
		{
			return CHECK_ERR_SEIGOSEI;
		}
		
		// ---エラーパターンチェックを実行する
		String[] pattern = new String[] {hktgMotoPattern, hktgSakiPattern};
		
		if (true == checkArray(pattern, errorPatternArray))
		{
			return CHECK_ERR_PATTERN;
		}
		
		return CHECK_OK;
	}
	
	/**
	 * 引継元存在判別処理
	 * @param svcKeiMapList	現行サービス契約リスト
	 * @param hojinFlg	法人フラグ
	 * @return	判別結果
	 * @throws CAANException
	 */
	private static String checkHktgMotoPattern(List<Map<String, String>> svcKeiMapList, boolean hojinFlg) throws CAANException
	{
		// ---現行サービス契約リストチェック
		
		// 現行サービス契約リストが存在しない場合
		if (null == svcKeiMapList || svcKeiMapList.size() == 0)
		{
			// これから登録される工事案件
			return HKTG_MI_TOROKU;
		}
		
		// ---工事案件情報取得
		
		List<CAANMsg> ku0011MsgList = new ArrayList<CAANMsg>();
		
		// 現行サービス契約リストの全てで実行する
		for (int i = 0; i < svcKeiMapList.size(); ++i)
		{
			// 現行サービス契約に紐付く工事案件を取得する
			CAANMsg[] tempKu0011MsgArray = selectKU0011Hktg(svcKeiMapList.get(i).get(MAP_KOJIAK_NO));
			
			// 取得できた場合
			if (null != tempKu0011MsgArray && tempKu0011MsgArray.length == 1)
			{
				// リストに設定する
				ku0011MsgList.add(tempKu0011MsgArray[0]);
			}
		}
		
		// ---工事案件情報チェック
		
		// 工事案件が存在しない場合
		if (ku0011MsgList.size() == 0)
		{
			// 引継元が存在しない工事案件
			return JKUStrConst.HKTG_MOTO_NASI;
		}
		// 工事案件が複数存在する場合
		else if (ku0011MsgList.size() != 1)
		{
			// スキーマ整合性エラー
			return HKTG_SCHEMA_ERR;
		}
		
		CAANMsg ku0011Msg = ku0011MsgList.get(0);
		
		// ---法人サービス契約情報チェック
		
		String hojinMotoPattern = JKUStrConst.HKTG_MOTO_NASI;
		
		// 法人の場合は実行しない
		if (false == hojinFlg)
		{
			// 法人サービス契約情報を取得する
			List<Map<String, String>> hojinSvcKeiMap =
				selectKU0071Map(getAddMotoSvcKeiNo(ku0011Msg.getString(KU0011ETMsg.KOJIAK_NO)));
			
			// 法人サービス契約が存在する場合
			if (null != hojinSvcKeiMap && hojinSvcKeiMap.size() != 0)
			{
				// IOから引継完了の工事案件
				hojinMotoPattern = JKUStrConst.HKTG_FIN_FROM_IO;
				
				for(int i = 0; i < hojinSvcKeiMap.size(); ++i)
				{
					// 完了していない法人が存在した場合
					if (JKUStrConst.MAX_YMD.equals(hojinSvcKeiMap.get(i).get(MAP_SVKEI_KJAK_TENDYMD)))
					{
						// IOから引継中の工事案件
						hojinMotoPattern = JKUStrConst.HKTG_CHU_FROM_IO;
					}
				}
			}
		}
		
		// ---サービス契約情報チェック
		
		String netMotoPattern = JKUStrConst.HKTG_MOTO_NASI;
		
		// サービス契約情報を取得する
		List<Map<String, String>> netSvcKeiMap =
			selectKU0081Map(getAddMotoSvcKeiNo(ku0011Msg.getString(KU0011ETMsg.KOJIAK_NO)));
		
		// サービス契約が存在する場合
		if (null != netSvcKeiMap && netSvcKeiMap.size() != 0)
		{
			// HTから引継完了の工事案件
			netMotoPattern = JKUStrConst.HKTG_FIN_FROM_HT;
			
			for (int i = 0; i < netSvcKeiMap.size(); ++i)
			{
				// 完了していないサービスが存在した場合
				if (JKUStrConst.MAX_YMD.equals(netSvcKeiMap.get(i).get(MAP_SVKEI_KJAK_TENDYMD)))
				{
					// HTから引継中の工事案件
					netMotoPattern = JKUStrConst.HKTG_CHU_FROM_HT;
				}
			}
		}
		
		// ---引継元結果返却
		
		// IOに引継元が存在しない場合
		if (JKUStrConst.HKTG_MOTO_NASI.equals(hojinMotoPattern))
		{
			// HTの引継元情報を返す
			return netMotoPattern;
		}
		// HTに引継元が存在しない場合
		if (JKUStrConst.HKTG_MOTO_NASI.equals(netMotoPattern))
		{
			// IOの引継元情報を返す
			return hojinMotoPattern;
		}
		
		// 引継元が複数存在した場合,スキーマ整合性エラーを返す
		return HKTG_SCHEMA_ERR;
	}
	
	/**
	 * 引継先存在判別処理
	 * @param svcKeiNo	サービス契約番号
	 * @param svcKeiMapList	現行サービス契約リスト
	 * @return	判別結果
	 * @throws CAANException
	 */
	private static String checkHktgSakiPattern(String svcKeiNo, List<Map<String, String>> svcKeiMapList) throws CAANException
	{
		
		// ---現行サービス契約リストチェック
		
		// 現行サービス契約リストが存在しない場合
		if (null == svcKeiMapList || svcKeiMapList.size() == 0)
		{
			// これから登録される工事案件
			return HKTG_MI_TOROKU;
		}
		
		// ---工事案件情報取得
		
		CAANMsg[] ku0011MsgArray = getKojiakNoWhereAddMtSvkeiNo(svcKeiNo);
		
		// ---結果件数確認
		
		int ku0011Length = 0;
		
		if (null != ku0011MsgArray)
		{
			ku0011Length = ku0011MsgArray.length;
		}
		
		if (1 < ku0011Length)
		{
			return HKTG_SCHEMA_ERR;
		}
		
		// ---引継先結果返却
		
		boolean endFlg = true;
		
		for (int i = 0; i < svcKeiMapList.size(); ++i)
		{
			if (JKUStrConst.MAX_YMD.equals(svcKeiMapList.get(i).get(MAP_SVKEI_KJAK_TENDYMD)))
			{
				endFlg = false;
				break;
			}
		}
		
		// 適用終了していないデータが存在する場合
		if (false == endFlg)
		{
			if (1 == ku0011Length)
			{
				// 引継実行中の工事案件
				return JKUStrConst.HKTG_CHU;
			}
			else
			{
				// 引継先が存在しない工事案件
				return JKUStrConst.HKTG_SAKI_NASI;
			}
		}
		// 全てのデータが適用終了している場合
		else
		{
			if (1 == ku0011Length)
			{
				// 引継が完了した工事案件
				return JKUStrConst.HKTG_FIN;
			}
			else
			{
				// 解約された工事案件
				return JKUStrConst.HKTG_SAKI_NASI_KAIYAKU;
			}
		}
	}
	
	/**
	 * 引継パターン整合性チェック
	 * @param hktgMotoPattern	引継元存在判別処理結果
	 * @param hktgSakiPattern	引継先存在判別処理結果
	 * @return チェック結果
	 */
	private static boolean checkHktgSeigosei(String hktgMotoPattern, String hktgSakiPattern)
	{
		// ---処理結果単項目チェック
		
		// 引継元結果が無い、もしくはエラーの場合
		if (null == hktgMotoPattern || HKTG_SCHEMA_ERR.equals(hktgMotoPattern))
		{
			return false;
		}
		
		// 引継先がない、もしくはエラーの場合
		if (null == hktgSakiPattern || HKTG_SCHEMA_ERR.equals(hktgSakiPattern))
		{
			return false;
		}
		
		// ---整合性チェック
		
		// 引継元変換
		int hktgMotoArrayNo = convMotoPatternYInt(hktgMotoPattern);
		
		// 引継先変換
		int hktgSakiArrayno = convSakiPatternXInt(hktgSakiPattern);
		
		return SEIGOSEI_RESULT_ARRAY[hktgMotoArrayNo][hktgSakiArrayno];
	}
	
	/**
	 * 引継元パターンを元に整合性チェック用の配列要素番号を取得する
	 * @param hktgMotoPattern	引継元パターン
	 * @return	パターンに対応する整数
	 */
	private static int convMotoPatternYInt(String hktgMotoPattern)
	{
		//	1:引継元が存在しない工事案件
		if (JKUStrConst.HKTG_MOTO_NASI.equals(hktgMotoPattern))
		{
			return 1;
		}
		//	2:HTから引継中の工事案件
		if (JKUStrConst.HKTG_CHU_FROM_HT.equals(hktgMotoPattern))
		{
			return 2;
		}
		//	3:HTから引継完了の工事案件
		if (JKUStrConst.HKTG_FIN_FROM_HT.equals(hktgMotoPattern))
		{
			return 3;
		}
		//	4:IOから引継中の工事案件
		if (JKUStrConst.HKTG_CHU_FROM_IO.equals(hktgMotoPattern))
		{
			return 4;
		}
		//	5:IOから引継完了の工事案件
		if (JKUStrConst.HKTG_FIN_FROM_IO.equals(hktgMotoPattern))
		{
			return 5;
		}
		// 0:これから登録される工事案件
		return 0;
	}
	
	/**
	 * 引継先パターンを元に整合性チェック用の配列要素番号を取得する
	 * @param hktgSakiPattern	引継先パターン
	 * @return	パターンに対応する整数
	 */
	private static int convSakiPatternXInt(String hktgSakiPattern)
	{
		
		//	1:引継実行中の工事案件
		if (JKUStrConst.HKTG_CHU.equals(hktgSakiPattern))
		{
			return 1;
		}
		//	2:引継が完了した工事案件
		if (JKUStrConst.HKTG_FIN.equals(hktgSakiPattern))
		{
			return 2;
		}
		//	3:引継先が存在しない工事案件
		if (JKUStrConst.HKTG_SAKI_NASI.equals(hktgSakiPattern))
		{
			return 3;
		}
		//	4:解約された工事案件
		if (JKUStrConst.HKTG_SAKI_NASI_KAIYAKU.equals(hktgSakiPattern))
		{
			return 4;
		}
		//	0:これから登録される工事案件
		return 0;
	}
	
	/**
	 * 引継関連工事案件検索処理
	 * @param kojiakNo	工事案件番号
	 * @param addSvcKeiNo	引継サービス契約番号
	 * @return	工事案件リスト
	 * @throws CAANException
	 */
	private static CAANMsg[] selectKU0011Hktg(String kojiakNo) throws CAANException
	{
		// ---引数のチェック
		
		if (null == kojiakNo)
		{
			return null;
		}
		
		// ---工事案件の検索
		
		JKUejbKU0011SecProc ku0011SecProc = new JKUejbKU0011SecProc();
		CAANMsg ku0011Msg = new CAANMsg(KU0011ETMsg.class.getName());
		
		// 工事案件番号
		if (null != kojiakNo)
		{
			ku0011Msg.set(KU0011ETMsg.KOJIAK_NO, kojiakNo);
		}
		// 工事案件種別
		ku0011Msg.set(KU0011ETMsg.KOJIAK_SBT_CD, JKUStrConst.CD00577_SVC_ADD_KOJI_NON);
		// 無効フラグ
		ku0011Msg.set(KU0011ETMsg.MK_FLG, JKUStrConst.MK_FLG_YUKO);

		return ku0011SecProc.findByCondition(ku0011Msg);
	}
	
	/**
	 * サービス契約_工事案件情報検索処理
	 * @param svcKeiNo	サービス契約番号
	 * @return	現行サービス契約リスト
	 * @throws CAANException
	 */
	private static List<Map<String, String>> selectKU0081Map(String svcKeiNo) throws CAANException
	{
		List<Map<String, String>> retList = new ArrayList<Map<String, String>>();
		List<String> kojiakNoList = new ArrayList<String>();
		
		// ---サービス契約_工事案件の検索
		
		JKUejbKU0081SecProc ku0081SecProc = new JKUejbKU0081SecProc();
		CAANMsg ku0081Msg = new CAANMsg(KU0081ETMsg.class.getName());
		
		if (null == svcKeiNo)
		{
			return retList;
		}
		
		// サービス契約番号
		ku0081Msg.set(KU0081ETMsg.SVC_KEI_NO, svcKeiNo);
		// 無効フラグ
		ku0081Msg.set(KU0081ETMsg.MK_FLG, JKUStrConst.MK_FLG_YUKO);
		
		CAANMsg[] ku0081MsgArray = ku0081SecProc.findByCondition(ku0081Msg);
		
		if (null == ku0081MsgArray)
		{
			return retList;
		}
		
		// ---結果を戻り値の型に変換する
		
		for (int i = 0; i < ku0081MsgArray.length; ++i)
		{
			// 工事案件番号
			String kojiakNo = ku0081MsgArray[i].getString(KU0081ETMsg.KOJIAK_NO);
			// サービス契約_工事案件適用終了年月日
			String svkeiKojiakTEndYmd = ku0081MsgArray[i].getString(KU0081ETMsg.SVKEI_KOJIAK_TENDYMD);
			
			int listNo = kojiakNoList.indexOf(kojiakNo);
			
			// 戻り値にまだ存在しない場合
			if (-1 == listNo)
			{
				// マップに格納する
				Map<String, String> tempMap = new HashMap<String, String>();
				
				// 工事案件番号
				tempMap.put(MAP_KOJIAK_NO, kojiakNo);
				// サービス契約_工事案件適用終了年月日
				tempMap.put(MAP_SVKEI_KJAK_TENDYMD, svkeiKojiakTEndYmd);
				
				// マップをリストに追加する
				retList.add(tempMap);
				// 工事案件リストに追加する
				kojiakNoList.add(kojiakNo);
			}
			// 戻り値にすでに存在する場合
			else
			{
				// サービス契約_工事案件適用終了年月日が初期値の場合
				if (JKUStrConst.MAX_YMD.equals(svkeiKojiakTEndYmd))
				{
					// 適用終了年月日を初期値にする
					retList.get(listNo).put(MAP_SVKEI_KJAK_TENDYMD, JKUStrConst.MAX_YMD);
				}
			}
		}
		return retList;
	}
	
	/**
	 * 法人サービス契約_工事案件情報検索処理
	 * @param svcKeiNo	サービス契約番号
	 * @return	現行サービス契約リスト
	 * @throws CAANException
	 */
	private static List<Map<String, String>> selectKU0071Map(String svcKeiNo) throws CAANException
	{
		List<Map<String, String>> retList = new ArrayList<Map<String, String>>();
		List<String> kojiakNoList = new ArrayList<String>();
		
		if (null == svcKeiNo)
		{
			return retList;
		}
		// ---法人サービス契約_工事案件の検索
		
		JKUejbKU0071SecProc ku0071SecProc = new JKUejbKU0071SecProc();
		CAANMsg ku0071Msg = new CAANMsg(KU0071ETMsg.class.getName());

		// 法人ｅｏ読替サービス契約番号
		ku0071Msg.set(KU0071ETMsg.HJIN_EO_YKAE_SVKEI_NO, svcKeiNo);
		// 無効フラグ
		ku0071Msg.set(KU0071ETMsg.MK_FLG, JKUStrConst.MK_FLG_YUKO);
		
		CAANMsg[] ku0071MsgArray = ku0071SecProc.findByCondition(ku0071Msg);
		
		if (null == ku0071MsgArray)
		{
			return retList;
		}
		// ---結果を戻り値の型に変換する
		
		for (int i = 0; i < ku0071MsgArray.length; ++i)
		{
			// 工事案件番号
			String kojiakNo = ku0071MsgArray[i].getString(KU0071ETMsg.KOJIAK_NO);
			// サービス契約_工事案件適用終了年月日
			String svkeiKojiakTEndYmd = ku0071MsgArray[i].getString(KU0071ETMsg.HOJINSVKEI_KJAK_TENDYMD);
			
			int listNo = kojiakNoList.indexOf(kojiakNo);
			
			// 戻り値にまだ存在しない場合
			if (-1 == listNo)
			{
				// マップに格納する
				Map<String, String> tempMap = new HashMap<String, String>();
				
				// 工事案件番号
				tempMap.put(MAP_KOJIAK_NO, kojiakNo);
				// サービス契約_工事案件適用終了年月日
				tempMap.put(MAP_SVKEI_KJAK_TENDYMD, svkeiKojiakTEndYmd);
				
				// マップをリストに追加する
				retList.add(tempMap);
				// 工事案件リストに追加する
				kojiakNoList.add(kojiakNo);
			}
			// 戻り値にすでに存在する場合
			else
			{
				// サービス契約_工事案件適用終了年月日が初期値の場合
				if (JKUStrConst.MAX_YMD.equals(svkeiKojiakTEndYmd))
				{
					// 適用終了年月日を初期値にする
					retList.get(listNo).put(MAP_SVKEI_KJAK_TENDYMD, JKUStrConst.MAX_YMD);
				}
			}
		}
		return retList;
	}
	
	/**
	 * 工事案件番号に紐付く追加元サービス契約番号の取得
	 * @param kojiakNo	工事案件番号
	 * @return	追加元サービス契約番号
	 * @throws CAANException
	 */
	private static String getAddMotoSvcKeiNo(String kojiakNo) throws CAANException
	{
		String retStr = null;
		CAANMsg whereMsg = null;
		CAANMsg resultMsg = null;
		
		// ---工事案件の検索
		whereMsg = new CAANMsg(KU0021ETMsg.class.getName());
		
		// 工事案件番号
		whereMsg.set(KU0021ETMsg.KOJIAK_NO, kojiakNo);
		
		resultMsg = new JKUejbKU0011SecProc().findByPrimaryKey(whereMsg, true);
		
		if (null == resultMsg)
		{
			return null;
			
		}
		
		// ---取得するサブスキーマを判定する
		
		String pattern = null;
		
		if (null != resultMsg.getString(KU0011ETMsg.HOJIN_PRC_GRP_CD))
		{
			pattern = ADD_MOTO_SUB_PTN_IO;
		}
		else
		{
			if (null != resultMsg.getString(KU0011ETMsg.MANSION_BUKKEN_CD))
			{
				pattern = ADD_MOTO_SUB_PTN_MT;
			}
			else
			{
				pattern = ADD_MOTO_SUB_PTN_HT;
			}
		}
		
		// ---工事案件＜eo光ネット＞の検索
		
		if (ADD_MOTO_SUB_PTN_HT.equals(pattern))
		{
			whereMsg = new CAANMsg(KU0021ETMsg.class.getName());
			
			// 工事案件番号
			whereMsg.set(KU0021ETMsg.KOJIAK_NO, kojiakNo);
			
			resultMsg = new JKUejbKU0021SecProc().findByPrimaryKey(whereMsg, true);
			
			if (null != resultMsg)
			{
				retStr = resultMsg.getString(KU0021ETMsg.ADD_MOTO_SVC_KEI_NO);
			}
		}

		
		// ---工事案件＜eoオフィス＞の検索
		if (ADD_MOTO_SUB_PTN_IO.equals(pattern))
		{
			whereMsg = new CAANMsg(KU0051ETMsg.class.getName());
			
			// 工事案件番号
			whereMsg.set(KU0051ETMsg.KOJIAK_NO, kojiakNo);
			
			resultMsg = new JKUejbKU0051SecProc().findByPrimaryKey(whereMsg, true);
			
			if (null != resultMsg)
			{
				retStr = resultMsg.getString(KU0051ETMsg.ADD_MOTO_SVC_KEI_NO);
			}
		}
			
		// ---工事案件＜eo光ネットマンション＞の検索
		
		if (ADD_MOTO_SUB_PTN_MT.equals(pattern))
		{
			
			whereMsg = new CAANMsg(KU0061ETMsg.class.getName());
			
			// 工事案件番号
			whereMsg.set(KU0061ETMsg.KOJIAK_NO, kojiakNo);
			
			resultMsg = new JKUejbKU0061SecProc().findByPrimaryKey(whereMsg, true);
			
			if (null != resultMsg)
			{
				retStr = resultMsg.getString(KU0061ETMsg.ADD_MOTO_SVC_KEI_NO);
			}
		}
		return retStr;
	}
	
	/**
	 * 追加元サービス契約番号に紐付く引継関連工事案件検索処理
	 * @param addMotoSvcKeiNo	追加元サービス契約番号
	 * @return	工事案件番号リスト
	 * @throws CAANException
	 */
	private static CAANMsg[] getKojiakNoWhereAddMtSvkeiNo(String addMotoSvcKeiNo) throws CAANException
	{
		
		if (null == addMotoSvcKeiNo)
		{
			return null;
		}
		List<String> kojiakNoList = new ArrayList<String>();
		CAANMsg whereMsg = null;
		CAANMsg[] resultArray = null;
		String kojiakNo = null;
		
		// ---工事案件＜eo光ネット＞の検索
		
		whereMsg = new CAANMsg(KU0021ETMsg.class.getName());
		// 追加元サービス契約番号
		whereMsg.set(KU0021ETMsg.ADD_MOTO_SVC_KEI_NO, addMotoSvcKeiNo);
		// 無効フラグ
		whereMsg.set(KU0021ETMsg.MK_FLG, JKUStrConst.MK_FLG_YUKO);
		resultArray = new JKUejbKU0021SecProc().findByCondition(whereMsg);
		
		if (null != resultArray)
		{
			for (int i = 0; i < resultArray.length; ++i)
			{
				kojiakNo = resultArray[i].getString(KU0021ETMsg.KOJIAK_NO);
				if (-1 == kojiakNoList.indexOf(kojiakNo))
				{
					kojiakNoList.add(kojiakNo);
				}
			}
		}
		// ---工事案件＜eoオフィス＞の検索
		
		whereMsg = new CAANMsg(KU0051ETMsg.class.getName());
		// 追加元サービス契約番号
		whereMsg.set(KU0051ETMsg.ADD_MOTO_SVC_KEI_NO, addMotoSvcKeiNo);
		// 無効フラグ
		whereMsg.set(KU0051ETMsg.MK_FLG, JKUStrConst.MK_FLG_YUKO);
		resultArray = new JKUejbKU0051SecProc().findByCondition(whereMsg);
		
		if (null != resultArray)
		{
			for (int i = 0; i < resultArray.length; ++i)
			{
				kojiakNo = resultArray[i].getString(KU0051ETMsg.KOJIAK_NO);
				if (-1 == kojiakNoList.indexOf(kojiakNo))
				{
					kojiakNoList.add(kojiakNo);
				}
			}
		}
		
		// ---工事案件＜eo光ネットマンション＞の検索
		
		whereMsg = new CAANMsg(KU0061ETMsg.class.getName());
		// 追加元サービス契約番号
		whereMsg.set(KU0061ETMsg.ADD_MOTO_SVC_KEI_NO, addMotoSvcKeiNo);
		// 無効フラグ
		whereMsg.set(KU0061ETMsg.MK_FLG, JKUStrConst.MK_FLG_YUKO);
		resultArray = new JKUejbKU0061SecProc().findByCondition(whereMsg);
		
		if (null != resultArray)
		{
			for (int i = 0; i < resultArray.length; ++i)
			{
				kojiakNo = resultArray[i].getString(KU0061ETMsg.KOJIAK_NO);
				if (-1 == kojiakNoList.indexOf(kojiakNo))
				{
					kojiakNoList.add(kojiakNo);
				}
			}
		}
		
		// ---工事案件の検索
		
		JKUejbKU0011SecProc ku0011SecProc = new JKUejbKU0011SecProc();
		List<CAANMsg> retList = new ArrayList<CAANMsg>();
		whereMsg = new CAANMsg(KU0011ETMsg.class.getName());
		// 工事案件種別
		whereMsg.set(KU0011ETMsg.KOJIAK_SBT_CD, JKUStrConst.CD00577_SVC_ADD_KOJI_NON);
		// 無効フラグ
		whereMsg.set(KU0011ETMsg.MK_FLG, JKUStrConst.MK_FLG_YUKO);
		for (int i = 0; i < kojiakNoList.size(); ++i)
		{
			// 工事案件番号
			whereMsg.set(KU0011ETMsg.KOJIAK_NO, kojiakNoList.get(i));
			
			resultArray = ku0011SecProc.findByCondition(whereMsg);
			if (null != resultArray)
			{
				for (int j = 0; j < resultArray.length; ++j)
				{
					retList.add(resultArray[i]);
				}
			}
			
		}
		if (retList == null)
		{
			return null;
		}
		return retList.toArray(new CAANMsg[retList.size()]);
	}
	
	/**
	 * 配列突合処理
	 * @param array1	配列１
	 * @param array2	配列２
	 * @return	突合結果（合致するものが存在する場合true）
	 */
	private static boolean checkArray(String[] array1, String[] array2)
	{
		if (null == array1 || null == array2)
		{
			return false;
		}
		
		for (int i = 0; i < array1.length; ++i)
		{
			if (null == array1[i])
			{
				continue;
			}
			
			for (int j = 0; j < array2.length; ++j)
			{
				if (null == array2[j])
				{
					continue;
				}
				if (array1[i].equals(array2[j]))
				{
					return true;
				}
			}
		}
		return false;
	}
}