/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JCHTushinSvcPrcChohyoCC
*   ソースファイル名：JCHTushinSvcPrcChohyoCC.java
*   作成者          ：FJ
*   日付            ：2011年12月08日
*＜機能概要＞
*   通信サービス料金帳票出力CC部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/12/08	富士通		新規作成
*   v5.00.00	2013/07/03  FJ) 林	   【LT-2013-0000205】 随時請求画面にて入力された送付先名を帳票に出力する対応
*   v5.01.00	2013/07/04  FJ) 垣内   【LT-2013-0000231】 随時請求画面にて入力されたお知らせを帳票に出力する対応
*   v5.02.00	2013/07/06  FJ) 垣内   【LT-2013-0000231】 請求書再発行と随時請求のフラグ判定追加、PGReliefによる修正
*   v5.03.00	2013/07/10  FJ) 文元   【LT-2013-0000261】 随時請求画面にて入力された部課名と担当者名を帳票に出力する対応
*   v5.03.01	2013/07/12  FJ) 楠神   【LT-2013-0000413】 金額内訳表示対応
*   v5.03.02	2013/07/12  FJ) 楠神   【LT-2013-0000434】 内訳帳票鑑非表示対応
*   v5.03.03	2013/07/12  FJ) 楠神   【LT-2013-0000393】 PDF表示内容不正対応
*	v5.04.00	2013/07/14  FJ) 早崎   【LT-2013-0000462】 領収振り替日および次回振替日が不正対応
*	v5.05.00	2013/07/15  FJ) 早崎   【LT-2013-0000480】 前月領収がない場合のマスク化条件修正
*	v5.06.00	2013/07/15  FJ) 垣内   【LT-2013-0000480】 請求年月マスク化部分マッピング修正
*	v5.07.00	2013/07/19  FJ) 早崎   【IT1-2013-0001413】 窓口請求書発行時のコンビニ支払期限編集追加
*	v5.08.00	2013/07/20  FJ) 早崎   【IT1-2013-0001413】 請求年月の年部分を下２桁に編集
*	v5.09.00	2013/07/23  FJ) 小野   【LT-2013-0000588】 前受金充当された請求の、うち消費税が"＊"で表示されない
*	v5.10.00	2013/07/24  FJ) 垣内   【LT-2013-0000614】 請求書再発行の場合はカスタマーバーコードを出力しない
*	v5.11.00	2013/07/27	FJ) 小野   【LT-2013-0000615】 当月以外ご請求金額（鑑）を金額、金額内訳両方に出力させる
*	v5.12.00	2013/07/29	FJ) 小野   【LT-2013-0000616】 一部収納済である請求の、うち消費税が"＊"で表示されない
*	v5.13.00	2013/08/06	FJ) 小野   【LT-2013-0000686】 随時請求書登録から印刷した場合、システムエラーとなる
*	v5.14.00	2013/08/08	FJ) 早崎   【IT1-2013-0001569】口振領収証のみの場合は請求年月当月で請求情報を取得
*	v5.15.00	2013/08/24	FJ) 小野   【OM-2013-0000866】 内訳書に未納合算分の明細は出力しないように変更(請求書再発行、請求内訳再発行)
*	v5.16.00	2013/09/27  FJ) 垣内   【OM-2013-0002587】 OCR番号のバージョン情報を固定値で設定
*	v5.17.00	2013/10/17	FJ) 小野   【OM-2013-0003186】 金額（請求税額）の料金項目コードを00900910201に変更。
*	v5.18.00	2013/10/29	FJ) 小野   【OM-2013-0003539】 請求内訳にデータが存在しない場合、処理を終了し画面にメッセージを表示させるように変更。
*	v5.19.00	2013/11/16	FJ) 田内   【OM-2013-0004392】 収入印紙貼付欄のマスク化を行う際の判定対象を変更。
*	v5.20.00	2013/11/17	FJ) 垣内   【OM-2013-0004459】 口振領収証のみの場合の振替日取得条件変更
*	v6.00.00	2013/11/18	FJ) 鈴木   【ANK-1750-00-00】  請求内訳の整理番号が１種類しかない場合でも整理番号を表示するように変更
*	v6.00.01	2013/11/21	FJ) 北端   【OM-2013-0004389】 収入印紙貼付欄マスク化有無の判定金額閾値を業務パラメータの「印紙税対象金額」から取得。
*	v8.00.00	2014/01/20	FJ) 北端   【ANK-1589-00-00】消費税に伴う料金施策（増税対応）
*	v8.00.01	2013/02/14  FJ) 江森   【OM-2014-0000814】 整理番号表示不正対応
*	v8.00.02	2014/03/11	FJ) 北端   【IT2-2014-0000150】口振領収書のみ出力時の収入印紙マスクの不備修正
*	v9.00.00	2014/04/16	FJ) 小野   【ANK-2054-00-00】eoスマートリンク改修(端末補償)により、料金内訳が30文字を超える場合、超過する部分を切り捨てるように修正。
*	v9.00.01	2014/06/04	FJ) 鈴木   【OM-2014-0001921】住所欄のフォントサイズ不正対応
*	v9.00.02	2014/06/17	FJ）江森   【OM-2013-0005201】消費税編集時の合算フラグ取得方法変更
*	v9.00.03	2014/06/20	FJ)	中井	【ANK-1979-00-00】mineo単独契約時の請求書「問合せ先」出力変更対応
*	v12.00.00	2014/12/02	FJ)	桑島   【OM-2014-0003652】EANバーコードの出力対応
*	v12.01.00	2015/01/06	FJ)	福岡    【ANK-2225-00-00】mineo単独契約時の請求書「問合せ先」出力改善
*	v15.00.00	2015/08/19	FJ)	辰野   【OM-2015-0001709】金融機関情報マスク化不備対応
*	v52.00.00	2020/10/20	FJ) 三原	【ANK-3838-00-00】窓口払い手数料の顧客負担方式導入
*	v54.00.00	2021/09/10	FJ) 南	   【OM-2021-0000584】口振請求書の印字項目を設計書通りに修正
*   v57.00.00   2022/02/24  FJ) 森脇   【ANK-4175-00-00】明細書当月請求欄の0円以下マスク化廃止対応
*   v61.00.00	2022/10/05	FJ) 鈴木   【ANK-4326-00-00】mineo料金メール署名欄、請求書変更対応
*   v64.00.00   2023/04/05  FJ) 原田   【#81816】ANK-4323-00-00_mineo請求明細の利用期間表示変更	対応漏れ
*   v66.00.00   2023/04/25  FJ) 中原   【ANK-4418-00-00】mineo譲渡手数料の集計先変更対応
*   v67.00.00   2023/06/14  FJ) 藤本涼 【ANK-4401-00-00】インボイス対応
*   v67.00.01	2023/06/23  FJ) 吉田あ 【ANK-4401-00-00】インボイス対応 追加タイトル、適格請求書発行事業者登録番号を取得
*   v67.00.02	2023/07/28  FJ) 吉田あ 【IT1-2023-0000023】インボイス対応 追加タイトル、適格請求書発行事業者登録番号の順に変更
*   v67.00.03	2023/08/30  FJ) 田中   【IT1-2023-0000051】インボイス対応 消費税が0円未満の場合マスク化対応
*   v67.00.04   2023/08/21  FJ) 中川   【ANK-4415-00-00】口振請求及びWeb申込システム移行 STEP1
*	v68.00.00   2023/10/13  FJ) 升岡   【ANK-4475-00-00】インボイス対応 STEP2
*   v68.00.01   2023/10/25  FJ) 寺田   【ANK-4475-00-00】インボイス対応 STEP2
*   v71.00.00   2024/04/01  FJ) 張     【ANK-4543-00-00】【eo定期】NTT卸対応：Step0
*   v71.00.01   2024/04/04  FJ）久山   【ANK-4468-00-00】eo光ネット「シンプルプラン」追加対応
*   v71.00.02   2024/05/20  FJ）久山   【ANK-4468-00-01】eo光ネット「シンプルプラン」追加対応
*   v71.00.03   2024/06/05  FJ）久山   【ANK-4468-00-02】eo光ネット「シンプルプラン」追加対応
*   v71.00.04   2024/06/14  FJ）久山   【ANK-4468-00-03】eo光ネット「シンプルプラン」追加対応
*   v71.00.00   2024/09/20  FJ）山岡   【ANK-4595-01-00】請求書の問い合わせ先追加対応
*   v71.00.01   2024/10/11  FJ）山岡   IT2-2024-0000013 【ANK-4595-01-00】請求書の問い合わせ先追加対応
*   v71.00.02   2024/10/15  FJ）山岡   IT2-2024-0000014 【ANK-4595-01-00】請求書の問い合わせ先追加対応
*   v71.00.03   2024/10/25  FJ）山岡   #85824【ANK-4595-01-00】請求書の問い合わせ先追加対応 障害対応
*   v73.00.00	2024/11/11  FJ) 張     【ANK-4427-00-00】NTT卸対応：STEP1
*   v73.00.01   2024/12/12  FJ）張     IT2-2024-0000082 【ANK-4427-00-00】NTT卸対応：STEP1
*   v73.00.02   2024/12/02  FJ）久山   【ANK-4427-10-00】NTT卸対応
*   v73.00.03	2025/01/10  FJ) 張     【IT1-2025-0000003】NTT卸対応：STEP1 
*   v73.00.04	2025/03/12  FJ) 張     【#86808】NHKのみ請求がtypeNとして出力されないように改修
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.io.ByteArrayOutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fujitsu.futurity.bp.custom.constant.JCHPrcTaioKirokAddConstCC;
import com.fujitsu.futurity.bp.custom.constant.JCHTushinSvcConstCC;
import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.CCException;
import com.fujitsu.futurity.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.AttachmentFileMapKeys;
import com.fujitsu.futurity.common.x01.sc.ErrorInfoMapKeys;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;

import eo.common.constant.JACStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JACCommonUtil;
import eo.common.util.JCHCommonBarcodeEdit;
import eo.common.util.JCHCommonFormatUtil;
import eo.common.util.JCHStampDutyUtil;
import eo.common.util.JCRUtilCommon;
import eo.common.util.JKKStringConverter;
import eo.common.util.JKKStringUtil;
import eo.common.util.JPCDateUtil;
import eo.common.util.JPCFomatString;
import eo.common.util.JPCUtilCommon;
import eo.ejb.cbm.entity.CH0101ETMsg;
import eo.ejb.cbs.cbsmsg.ECC0041A110CBSMsg;
import eo.ejb.cbs.cbsmsg.ECC0041A110CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0051A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0051A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0051B040CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0051B040CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0051B060CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0051B060CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0051B080CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0051B080CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0051B090CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0051B090CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0101B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0101B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0111B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0111B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0391A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0391A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0401B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0401B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0501B020CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501B020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0941A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0941A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0501B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0311A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0311A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0051B100CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0051B100CBSMsg1List;

/**
 * 請求収納の各サービスより呼び出される通信サービス料金帳票出力CC部品です。<p>
 * <BR>
 * @author FJ
 */
public class JCHTushinSvcPrcChohyoCC extends AbstractCommonComponent
{

	/** マップID */
	private static final String MAP_ID = "TUSHINSVCPRCCHOHYOCC";

	/** 再請求登録SC(請求書再発行) */
	private static final String MAP_ID_CHSV003901SC = "CHSV003901SC";

	/** 業務パラメータ管理情報取得マップID */
	private static final String GETWORKPARAMLISTCC = "GETWORKPARAMLISTCC";

	//ANK-4468-00-00 ADD START
	/** グループ計変更情報取得情報取得マップID */
	private static final String MAP_CC_ID_GETCHANGEGROUPKEIINFCC = "GETCHANGEGROUPKEIINFCC";
	//ANK-4468-00-00 ADD END

	/** 業務パラメータ管理一意照会明細 */
	private static final String EZM0321A010CBSMSG1LIST = "EZM0321A010CBSMsg1List";

	/** 業務機能識別コード（請求内訳表示用） */
	private static final String WORK_KINO_SKBT_SEIKY_UCHWK = "SKY_U_DSP";

	/** 業務機能識別コード（請求内訳データ作成（合計）） */
	private static final String WORK_KINO_SKBT_SEIKY_UCHWK_GKI = "SKY_U_GKI";

	/** 帳票区分（請求書(窓口_企業負担)） */
	private static final String LIST_KBN_MADO = "1";

	/** 帳票区分（請求書(口座振替)） */
	private static final String LIST_KBN_KOZA = "2";

	/** 帳票区分（請求書(クレジット)） */
	private static final String LIST_KBN_CREZ = "3";

	/** 帳票区分（請求書(口座振替領収書のみ)） */
	private static final String LIST_KBN_KOZA_RCPT = "4";

	/** 帳票区分（通信サービス料金内訳） */
	private static final String LIST_KBN_SVCR = "5";

	// ANK-3838-00-00 ADD START
	/** 帳票区分（請求書(窓口_顧客負担)） */
	private static final String LIST_KBN_MADO_CUST = "6";
	// ANK-3838-00-00 ADD END

	/** 内訳出力フラグ（出力あり） */
	private static final String UCWK_OPUT_FLG_ON = "1";

	/** 日付区分（年） */
	private static final String DATE_KBN_YEAR = "1";

	/** 日付区分（月） */
	private static final String DATE_KBN_MON = "2";

	/** 日付区分（日） */
	private static final String DATE_KBN_DAY = "3";

	/** 金額編集パターンコード（"０"） */
	private static final String AMNT_HENSHU_PTN_CD_0 = "0";

	/** 金額編集パターンコード（"１"） */
	private static final String AMNT_HENSHU_PTN_CD_1 = "1";

	/** 金額編集パターンコード（"２"） */
	private static final String AMNT_HENSHU_PTN_CD_2 = "2";

	/** 金額編集最大桁数 */
	private static final int AMNT_HENSHU_KETA_MAX = 15;

	/** 金額編集最大桁数-1（括弧インデント対応） */
	private static final int AMNT_HENSHU_KETA_KAKKO_IDT = 14;

	/** 帳票出力＿お客様名文字数 */
	private static final int CHOHYO_OUT_NAME_LENGTH = 15;

	/** 帳票出力＿クレジット会社名文字数 */
	private static final int CHOHYO_OUT_CRECA_COMP_NM_LENGTH = 20;

	/** 帳票出力＿金融機関名文字数 */
	private static final int CHOHYO_OUT_BANK_NM_LENGTH = 15;
	
	/** 帳票出力＿金融機関支店名文字数 */
	private static final int CHOHYO_OUT_BANK_SHITEN_NM_LENGTH = 15;

	/** テンプレートID(請求契約一意照会) */
	private static final String TEMPLATE_ID_EKK0491A010 = "EKK0491A010";

	/** テンプレートID(請求一意照会) */
	private static final String TEMPLATE_ID_ECH0051A010 = "ECH0051A010";

	/** テンプレートID(請求内訳一覧照会) */
	private static final String TEMPLATE_ID_ECH0101B010 = "ECH0101B010";

	/** テンプレートID(料金スケジュール定義一覧照会) */
	private static final String TEMPLATE_ID_ECH0501B020 = "ECH0501B020";

	/** テンプレートID(請求一覧照会（請求書料金情報）) */
	private static final String TEMPLATE_ID_ECH0051B040 = "ECH0051B040";

	/** テンプレートID(帳票生成) */
	private static final String TEMPLATE_ID_ECC0041A110 = "ECC0041A110";

	/** テンプレートID(業務パラメータ管理一意照会照会) */
	private static final String TEMPLATE_ID_EZM0321A010 = "EZM0321A010";

	/** テンプレートID(料金項目抽出変換一覧照会) */
	private static final String TEMPLATE_ID_ECH0401B010 = "ECH0401B010";

// v12.01.00 ADD START
	/** テンプレートID(mineo未納分単独請求チェック) */
	private static final String TEMPLATE_ID_ECH0051B060 = "ECH0051B060";
// v12.01.00 ADD END
// ANK-4595-01-00 ADD START 
	/** テンプレートID(電気未納分単独請求チェック) */
	private static final String TEMPLATE_ID_ECH0051B080 = "ECH0051B080";
	/** テンプレートID(電気未納分単独請求チェック) */
	private static final String TEMPLATE_ID_ECH0051B090 = "ECH0051B090";
	// ANK-4595-01-00 ADD END
	
	// ANK-3838-00-00 ADD START
	/** テンプレートID(パーフェクト口座一意照会) */
	private static final String TEMPLATE_ID_ECH0941A010 = "ECH0941A010";
	// ANK-3838-00-00 ADD END

	// ANK-4401-00-00 ADD START
	/** テンプレートID(システムパラメータ管理一意照会) */
	private static final String TEMPLATE_ID_EZM0311A010 = "EZM0311A010";
	// ANK-4401-00-00 ADD END

	// ANK-4415-00-00 ADD START
	/** テンプレートID(入金一覧照会) */
	private static final String TEMPLATE_ID_ECH0111B010 = "ECH0111B010";

	/** テンプレートID(料金スケジュール定義一意照会) */
	private static final String TEMPLATE_ID_ECH0501A010 = "ECH0501A010";

	/** テンプレートID(口座一覧照会（口座支払方法受付区分）) */
	private static final String TEMPLATE_ID_EKK0501B002 = "EKK0501B002";
	// ANK-4415-00-00 ADD END

// ANK-4475-00-00 ADD START
	/** テンプレートID(料金項目出力名称一意照会) */
	private static final String TEMPLATE_ID_ECH0391A010 = "ECH0391A010";
// ANK-4475-00-00 ADD END
	
	/** 料金項目抽出変換一覧明細 */
	private static final String COL_ECH0401B010LIST1 = "ECH0401B010CBSMsg1List1";
	
	/** 料金項目抽出変換一覧明細 */
	private static final String COL_ECH0401B010LIST2 = "ECH0401B010CBSMsg1List2";

	/** 料金項目抽出変換一覧明細配列 */
	private static final String[] COL_ECH0401B010LISTS =
		new String[] {COL_ECH0401B010LIST1, COL_ECH0401B010LIST2};

	/** 業務パラメータＩＤ１ */
	private static final String WK_PARA_ID1 = "CH_WKS_SK_BOTH_DISP";

	/** 業務機能識別コードの件数 */
	private static final int WORK_KINO_SKBTCD_LENGTH = 2;

	/** 業務パラメータＩＤ配列 */
	private static final String[] WK_PARA_IDS = new String[] {WK_PARA_ID1};

	//ANK-4418-00-00 ADD START
	/** 業務パラメータＩＤ２ */
	private static final String WK_PARA_ID2 = "CH_MVNO_ONLY_PRC_KMK";

	/** 業務パラメータＩＤ配列 */
	private static final String[] WK_PARA_IDM = new String[] {WK_PARA_ID2};
	
	/** 業務パラメータ管理一意明細2 */
	private static final String COL_EZM0321A010LIST2 = "EZM0321A010CBSMsg1List2";

	/** 業務パラメータ管理一意明細配列 */
	private static final String[] COL_EZM0321A010LISTM = 	new String[] {COL_EZM0321A010LIST2};
	//ANK-4418-00-00 ADD END
	
	/** 業務パラメータ管理一意明細1 */
	private static final String COL_EZM0321A010LIST1 = "EZM0321A010CBSMsg1List1";

	/** 業務パラメータ管理一意明細配列 */
	private static final String[] COL_EZM0321A010LISTS = 	new String[] {COL_EZM0321A010LIST1};

	/** 曜日コード（1:日） */
	private static final String DAY1_CODE = "1";

	/** 曜日コード（2:月） */
	private static final String DAY2_CODE = "2";

	/** 曜日コード（3:火） */
	private static final String DAY3_CODE = "3";

	/** 曜日コード（4:水） */
	private static final String DAY4_CODE = "4";

	/** 曜日コード（5:木） */
	private static final String DAY5_CODE = "5";

	/** 曜日コード（6:金） */
	private static final String DAY6_CODE = "6";

	/** 曜日コード（7:土） */
	private static final String DAY7_CODE = "7";

	/** 曜日名称（1:日） */
	private static final String DAY1_NM = "日";

	/** 曜日名称（2:月） */
	private static final String DAY2_NM = "月";

	/** 曜日名称（3:火） */
	private static final String DAY3_NM = "火";

	/** 曜日名称（4:水） */
	private static final String DAY4_NM = "水";

	/** 曜日名称（5:木） */
	private static final String DAY5_NM = "木";

	/** 曜日名称（6:金） */
	private static final String DAY6_NM = "金";

	/** 曜日名称（7:土） */
	private static final String DAY7_NM = "土";

	// ANK-3838-00-00 DEL START
	///** 帳票定義NO（請求書(窓口)） */
	//private static final String CHOHYO_MADO_NO = "PCHZ00000000001"; 
	// ANK-3838-00-00 DEL END
	/** 帳票定義NO（請求書(口座振替)） */
	private static final String CHOHYO_KOZA_NO = "PCHZ00000000002"; 
	/** 帳票定義NO（請求書(クレジット)） */
	private static final String CHOHYO_CREZ_NO = "PCHZ00000000003"; 
	/** 帳票定義NO（通信サービス料金内訳） */
	private static final String CHOHYO_SVCR_NO = "PCHZ00000000004"; 
	// ANK-3838-00-00 ADD START
	/** 帳票定義NO（請求書(窓口/コンビニ)） */
	private static final String CHOHYO_MADO_CONV_NO = "PCHZ00000000007"; 
	/** 帳票定義NO（請求書(窓口/コンビニ・パーフェクト)） */
	private static final String CHOHYO_MADO_CONV_PERF_NO = "PCHZ00000000008"; 
	/** 帳票定義NO（請求書(窓口/コンビニ・銀行)） */
	private static final String CHOHYO_MADO_CONV_BANK_NO = "PCHZ00000000009"; 
	// ANK-3838-00-00 ADD END

	/** 改行文字 */
	private static final String LINE_SEP = "line.separator";
	/**  カンマ区切り */
	public static final String CSV = ",";
	/** エスケープ文字 (")  */
	private static final String SINGLE_DBLQUOTE = "\"";
	/** 金額（カッコ有り左） */
	private static final String KNGK_KAKKO_ARI_L = "(";
	/** 金額（カッコ有り右） */
	private static final String KNGK_KAKKO_ARI_R = ")";
	/** 空行の行末判定文字列 */
	private static final String KUGYO_LINE_END = "\"\",\"\",\"\",\"\",\"\",\"\"" + System.getProperty(LINE_SEP);

	/** 
	 * 年月日書式(yyyyMMdd)の桁数 
	 */
	private static final int YMD = 8;

	/** 
	 * 日時書式(yyyyMMddHHmmss)の桁数 
	 */
	private static final int YMDHMS = 14;

// ANK-4475-00-00 ADD START
	/**
	 * 日付フォーマット：編集年月日
	 */
	public static final String FMT_EDIT_YMD = "yyyy/MM/dd";
// ANK-4475-00-00 ADD END
	
	/** 収入印紙貼付欄マスク化 */
	private static final String SN_INS_HRTK_MASK_AST = "*******";

	/** マスク_2桁 */
	private static final String MASK_HN_2 = "**";

	/** マスク_2桁 */
	private static final String MASK_ZN_2 = "＊＊";

	/** マスク_4桁 */
	private static final String MASK_4 = "****";

	/** マスク_7桁 */
	private static final String MASK_7 = "*******";

	/** マスク_半角_15桁 */
	private static final String MASK_HN_15 = "***************";

	/** マスク_全角_15桁 */
	private static final String MASK_ZN_15 = "＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊";

	/** 当月フラグ */
	private static final String TOGT_FLG = "0";

	/** 前月フラグ */
	private static final String ZENGT_FLG = "1";

	/** 固定値"0" */
	private static final String ZERO = "0";

	// ANK-3838-00-00 DEL START
//	/** 日付(20991231) */
//	private static final String CONTENT_YMD = "20991231";
//	
//	/** ハイフン(--) */
//	private static final String HYPHEN = "--";
	// ANK-3838-00-00 DEL END

	/** 住所分割文字数(通常) */
	private static final int ADDRESS_NORMAL_LINE_LENGTH = 24;

	/** 住所分割文字数(小さいサイズ) */
	private static final int ADDRESS_SMALL_LINE_LENGTH = 31;

	/** 住所分割数 */
	private static final int ADDRESS_SPLIT_COUNT = 4;

	/** 随時フラグ */
	private static final String ZUIJI_FLG = "1";

// 2014.06.04 OM-2014-0001921 add start
	/** 送付先住所の編集部品の結果 を格納するmapのキー */
	private static final String EDIT_FLG_KEY = "EDIT_FLG";
	/** 送付先住所の編集部品の結果 正常サイズ */
	private static final String EDIT_FLG_NORMAL = "NORMAL";
	/** 送付先住所の編集部品の結果 小さいサイズ */
	private static final String EDIT_FLG_SMALL = "SMALL";
// 2014.06.04 OM-2014-0001921 add end
	// ANK-3838-00-00 ADD START
	/** 支払用紙 コンビニ */
	private static final String PAY_YOSHI_CONV = "0";
	
	/** 支払用紙 コンビニ＋パーフェクト */
	private static final String PAY_YOSHI_CONV_PERF = "1";
	// ANK-3838-00-00 ADD END
	
	// OM-2021-0000584 ADD START
	/** 金融機関コード（ゆうちょ銀行,郵便局） */
	private static final String YUCHO_YUBIN_BANK_CD = "9900";
	// OM-2021-0000584 ADD END
	
	// ANK-4326-00-00 ADD START
	/** mineoお問い合わせ先６ 切替日 */
	private static final String tiawaseKirikaeDay = "20221211";
	// ANK-4326-00-00 ADD END

	// ANK-4418-00-00 ADD START
	/** mineo料金グループコード */
	private static final String PRC_GROUP_MINEO = "51";
	/** ◇初期費用等の料金項目コード */
	private static final String SHOKIHIY_OPRCKMKCD = "00900702601";
	// ANK-4418-00-00 ADD END
// ANK-4595-01-00 ADD START
	/** 電気料金グループコード */
	private static final String PRC_GROUP_ELEC = "17";
	/** マンションオーナー料金グループコード */
	private static final String PRC_GROUP_MTON = "99";
// ANK-4595-01-00 ADD END
	// ANK-4401-00-00 ADD START
	/** 契約者名表示制御フラグ（非表示） */
	private static final String KEISYA_NM_DSP_CTRL_FLG_0 = "0";
	// ANK-4401-00-00 ADD END

// ANK-4475-00-00 ADD START
	/** パートナー会員出力文章 */
	private static final String OROSI_OUTPUT_TEXT = "eo光パートナーサービスのご請求についてはeo光パートナー各社より行います。";
// ANK-4475-00-00 ADD END
	
	// ANK-4475-00-00 ADD START
	/** マンションオーナー向け表示制御フラグ（非表示） */
	private static final String KEY_MASION_OWNER_CTRL_FLG_0 = "0";
	// ANK-4475-00-00 ADD END
	//#86808 20250312 張 ADD START
	/** 料金コースコード */
	private static final String PRCS_CD_KU = "   ";
	//#86808 20250312 張 ADD END

	/**
	 * 通信サービス料金帳票出力
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite outputTushinSvcPrcChohyo(SessionHandle handle, 
			IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		if (inMap == null)
		{
			inMap = new HashMap<String, Object>();
			param.setData(MAP_ID, inMap);
		}

		// 機能コード ← 通信サービス料金帳票マップ．機能コード
		String funcCd = (String)inMap.get(JCHTushinSvcConstCC.FUNC_CD);

		// 機能コードが"0"の場合、処理せずに終了
		if("0".equals(funcCd))
		{
			return param;
		}

		// 帳票区分 ← 通信サービス料金帳票マップ．帳票出力依頼リスト．帳票区分
		String chohyoKbn = (String)inMap.get("chohyo_kbn");
		// 内訳出力フラグ ← 通信サービス料金帳票マップ．帳票出力依頼リスト．内訳出力フラグ
		String ucwkOputFlg = (String)inMap.get("ucwk_oput_flg");
		IRequestParameterReadWrite rtnParam = null;
		
		// ANK-3838-00-00 ADD START
		// 支払用紙 ← 通信サービス料金帳票マップ．帳票出力依頼リスト．支払用紙
		String payYoshi = (String)inMap.get("pay_yoshi");
		// ANK-3838-00-00 ADD END
		
		// 業務パラメータ管理一意照会の実行
		// 内訳両出力の業務パラメータ設定値を取得し、inMapにセットする。
		execEZM0321A010(handle, param, inMap);

		// 料金項目抽出変換一覧照会サービスインターフェイス
		// 内訳両出力の業務機能識別コードを取得する。
		execECH0401B010(handle, param, inMap);

		// 料金項目抽出変換一覧明細を取得
		List<HashMap<String, Object>> msgList = (ArrayList<HashMap<String, Object>>)inMap.get(COL_ECH0401B010LIST1);

		// 内訳両出力の料金項目コードを取得しマップに設定する（キーのみ使用）
		HashMap<String, String> bothDispMap = new HashMap<String, String>();
		for (HashMap<String, Object> msg : msgList)
		{
			StringBuilder key = new StringBuilder();
			key.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD))
				.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD))
				.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD))
				.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD));

			bothDispMap.put(key.toString(), null);
		}
		
// v12.01.00 MOD START
		
//		// mineo単独チェック
//		setMineoTandoku(handle, param, fixedText, inMap);
		
		// ANK-3838-00-00 MOD START
		//if (LIST_KBN_MADO.equals(chohyoKbn) && !isNotMisgGsky(handle, param, fixedText, inMap)) {
		if ((LIST_KBN_MADO.equals(chohyoKbn) || LIST_KBN_MADO_CUST.equals(chohyoKbn)) && !isNotMisgGsky(handle, param, fixedText, inMap)) {
		// ANK-3838-00-00 MOD END
			
			/** 帳票区分（請求書(窓口_企業負担)）又は 帳票区分（請求書(窓口_顧客負担)）である 且つ 未納合算あり */
			
			// 新規：mineo単独チェック（遡ってチェック）
			setMisgGskyMineoTandoku(handle, param, fixedText, inMap);
			
		} else {
			
			/** 帳票区分（請求書(窓口_企業負担)）ではない 且つ 帳票区分（請求書(窓口_顧客負担)）ではない場合 又は 未納合算なし */
			
			// 既存：mineo単独チェック
			setMineoTandoku(handle, param, fixedText, inMap);
		}
//ANK-4595-01-00 ADD START
		if ((LIST_KBN_MADO.equals(chohyoKbn) || LIST_KBN_MADO_CUST.equals(chohyoKbn)) && !isNotMisgGsky(handle, param, fixedText, inMap)) {
			/** 帳票区分（請求書(窓口_企業負担)）又は 帳票区分（請求書(窓口_顧客負担)）である 且つ 未納合算あり */

			// 新規：電気単独チェック（遡ってチェック）
			setMisgGskyElectTandoku(handle, param, fixedText, inMap);

		} else {
			/** 帳票区分（請求書(窓口_企業負担)）ではない 且つ 帳票区分（請求書(窓口_顧客負担)）ではない場合 又は 未納合算なし */

			// 既存：電気単独チェック
			setElectTandoku(handle, param, fixedText, inMap);

		}
		
		if ((LIST_KBN_MADO.equals(chohyoKbn) || LIST_KBN_MADO_CUST.equals(chohyoKbn)) && !isNotMisgGsky(handle, param, fixedText, inMap)) {
			/** 帳票区分（請求書(窓口_企業負担)）又は 帳票区分（請求書(窓口_顧客負担)）である 且つ 未納合算あり */

			// 新規：マンションオーナーチェック（遡ってチェック）
			setMisgGskyMtonTandoku(handle, param, fixedText, inMap);

		} else {
			/** 帳票区分（請求書(窓口_企業負担)）ではない 且つ 帳票区分（請求書(窓口_顧客負担)）ではない場合 又は 未納合算なし */

			// 既存：マンションオーナーチェック
			setMtonTandoku(handle, param, fixedText, inMap);
		}
//ANK-4595-01-00 ADD END
//ANK-4427-00-00 ADD START
		if ((LIST_KBN_MADO.equals(chohyoKbn) || LIST_KBN_MADO_CUST.equals(chohyoKbn)) && !isNotMisgGsky(handle, param, fixedText, inMap)) {
			/** 帳票区分（請求書(窓口_企業負担)）又は 帳票区分（請求書(窓口_顧客負担)）である 且つ 未納合算あり */

			// 新規：NTT卸単独チェック（遡ってチェック）
			setMisgGskyNttoTandoku(handle, param, fixedText, inMap);

		} else {
			/** 帳票区分（請求書(窓口_企業負担)）ではない 且つ 帳票区分（請求書(窓口_顧客負担)）ではない場合 又は 未納合算なし */

			// 既存：NTT卸単独チェック
			setNttoTandoku(handle, param, fixedText, inMap);

		}
//ANK-4427-00-00 ADD END
// v12.01.00 MOD END
		//ANK-4468-00-00 ADD START
		//シンプルプラングループ計変更情報取得
		getChangeGroupKei(handle, param, MAP_CC_ID_GETCHANGEGROUPKEIINFCC);
		//ANK-4468-00-00 ADD END
		
		// 帳票区分が請求書(窓口_企業負担)の場合
		if(LIST_KBN_MADO.equals(chohyoKbn))
		{
			// 請求書(窓口/コンビニ・銀行)
			getInfoTushinSvcPrcSeiky(handle, param, fixedText, inMap);

			// CSV編集処理
			// ANK-3838-00-00 MOD START
			//byte[] csvData = makeCSVDataTushinSvcPrcSeiky(param, bothDispMap);
			byte[] csvData = makeCSVDataUsePrcSeikyshoMadoConvBank(param, bothDispMap);
			// ANK-3838-00-00 MOD END

			// 帳票生成処理
			// ANK-3838-00-00 MOD START
			//rtnParam = createList(handle, param, csvData, funcCd, CHOHYO_MADO_NO);
			rtnParam = createList(handle, param, csvData, funcCd, CHOHYO_MADO_CONV_BANK_NO);
			// ANK-3838-00-00 MOD END
		}
		// ANK-3838-00-00 ADD START
		// 帳票区分が請求書(窓口_顧客負担)の場合
		else if (LIST_KBN_MADO_CUST.equals(chohyoKbn))
		{
			// 支払用紙がコンビニの場合
			if (PAY_YOSHI_CONV.equals(payYoshi))
			{
				// 請求書(窓口／コンビニ)
				getInfoTushinSvcPrcSeiky(handle, param, fixedText, inMap);
				
				// CSV編集処理
				byte[] csvData = makeCSVDataUsePrcSeikyshoMadoCnv(param, bothDispMap);
				
				// 帳票生成処理
				rtnParam = createList(handle, param, csvData, funcCd, CHOHYO_MADO_CONV_NO);
			}
			// 支払用紙がコンビニ＋パーフェクトの場合
			else if (PAY_YOSHI_CONV_PERF.equals(payYoshi))
			{
				// 請求書(窓口／コンビニ・パーフェクト)情報取得処理
				getInfoSeikyshoMadoConvPerf(handle, param, fixedText, inMap);
				
				// CSV編集処理
				byte[] csvData = makeCSVDataUsePrcSeikyshoMadoConvPerf(param, bothDispMap);
				
				// 帳票生成処理
				rtnParam = createList(handle, param, csvData, funcCd, CHOHYO_MADO_CONV_PERF_NO);
			}
		}
		// ANK-3838-00-00 ADD END
		else if(LIST_KBN_KOZA.equals(chohyoKbn) || LIST_KBN_KOZA_RCPT.equals(chohyoKbn))
		{
			// 請求書(口座振替) ・請求書(口座振替領収書のみ)
			// ANK-4415-00-00 MOD START
			//getInfoTushinSvcPrcKoza(handle, param, fixedText, inMap, chohyoKbn);
			getInfoTushinSvcPrcKoza(handle, param, fixedText, inMap, chohyoKbn, funcCd);
			// ANK-4415-00-00 MOD END

			// CSV編集処理
			byte[] csvData = makeCSVDataTushinSvcPrcKoza(param, chohyoKbn, bothDispMap);

			// 帳票生成処理
			rtnParam = createList(handle, param, csvData, funcCd, CHOHYO_KOZA_NO);
		}
		else if(LIST_KBN_CREZ.equals(chohyoKbn))
		{
			// 請求書(クレジット)
			getInfoTushinSvcPrcInfo(handle, param, fixedText, inMap);

			// CSV編集処理
			byte[] csvData = makeCSVDataTushinSvcPrcInfo(param, bothDispMap);

			// 帳票生成処理
			rtnParam = createList(handle, param, csvData, funcCd, CHOHYO_CREZ_NO);
		}
		else if(LIST_KBN_SVCR.equals(chohyoKbn))
		{
// ANK-4475-00-00 MOD START
//
//			// 通信サービス料金内訳
//			getInfoTushinSvcPrcUcwk(handle, param, fixedText, inMap, false);
//
//			// CSV編集処理
//			byte[] csvData = makeCSVDataTushinSvcPrcUcwk(param, bothDispMap);
//
			// 出力リストの件数分だけ、通信サービス料金内訳・CSV編集処理を行い
			// 全件処理後に1つのCSVファイルに記録し、帳票生成処理を行う。
			ArrayList<HashMap<String, Object>> key_List = getMapListItem(param, "tushin_svc_prc_output_list");

			ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

			for (int idx = 0; idx < key_List.size(); idx++) {
				HashMap<String, Object> kirokMap = key_List.get(idx);
				// ＫＥＹ＿請求番号、ＫＥＹ＿請求年月を更新する。
				inMap.put(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_NO, (String) kirokMap.get("list_seiky_no"));
				inMap.put(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM, (String) kirokMap.get("list_seiky_ym"));

				// １件目はすでに行っているので２件目からチェックする。
				if (idx != 0) {
					if (!isNotMisgGsky(handle, param, fixedText, inMap)) {
						/** 未納合算あり */

						// 新規：mineo単独チェック（遡ってチェック）
						setMisgGskyMineoTandoku(handle, param, fixedText, inMap);
//ANK-4595-01-00 ADD START
						// 新規：eo電気単独チェック（遡ってチェック）
						setMisgGskyElectTandoku(handle, param, fixedText, inMap);

						// 新規：マンションオーナーチェック（遡ってチェック）
						setMisgGskyMtonTandoku(handle, param, fixedText, inMap);						
//ANK-4595-01-00 ADD END
//ANK-4427-00-00 ADD START
						// 新規：NTT卸単独チェック（遡ってチェック）
						setMisgGskyNttoTandoku(handle, param, fixedText, inMap);
//ANK-4427-00-00 ADD END
					} else {
						/** 未納合算なし */

						// 既存：mineo単独チェック
						setMineoTandoku(handle, param, fixedText, inMap);
//ANK-4595-01-00 ADD START
						// 既存：eo電気単独チェック
						setElectTandoku(handle, param, fixedText, inMap);

						// 既存：マンションオーナーチェック
						setMtonTandoku(handle, param, fixedText, inMap);
//ANK-4595-01-00 ADD END
//ANK-4427-00-00 ADD START
						// 既存：NTT卸単独チェック
						setNttoTandoku(handle, param, fixedText, inMap);
//ANK-4427-00-00 ADD END
					}
				}
				// 通信サービス料金内訳
				getInfoTushinSvcPrcUcwk(handle, param, fixedText, inMap, false);

				HashMap<String, Object> parentMapCC = null;
				parentMapCC = (HashMap<String, Object>) param.getData(MAP_ID);

				// 卸先事業者コード
				String orsjgs_Cd = (String) parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_ORSJGS_CD);

				if (orsjgs_Cd == null || "".equals(orsjgs_Cd)) {
					// 卸先事業者コード:卸ではない（null or 空）場合、CSV編集処理メソッドで対応
					// CSV編集処理
					outputStream.write(makeCSVDataTushinSvcPrcUcwk(param, bothDispMap));

				} else {
					// 卸先事業者コード:卸の場合、別のCSV編集処理メソッドで対応
					// CSV編集処理
					outputStream.write(makeCSVDataTushinSvcPrcUcwkOrsjgs(handle, param, inMap, bothDispMap, idx));
				}
				// 前件、請求一覧照会からSQL取得したデータが残ってしまい一部前件が残ったまま処理を行ってしまうため削除する。
				ArrayList childList = (ArrayList) parentMapCC.get("ECH0101B010CBSMsg1List");
//ANK-4543-00-00 ADD START
				//NTT卸契約エラー判定
				String NTT_ERR = "";
				if(childList != null )
				{
					for(int i = 0; i < childList.size(); i++ ){
						HashMap resultList01Map = (HashMap)childList.get(i);
						NTT_ERR = (String)resultList01Map.get("ntt_err_flg");
						kirokMap.put("ntt_err_flg", NTT_ERR);
						if(NTT_ERR.equals("1"))
						{
							break;
						}
					}
				}
//ANK-4543-00-00 ADD END
				childList.clear();
			}
			// 全件のデータを格納する。
			byte[] csvData = outputStream.toByteArray();

// ANK-4475-00-00 MOD END
			
			// 帳票生成処理
			rtnParam = createList(handle, param, csvData, funcCd, CHOHYO_SVCR_NO);
		}

		if(UCWK_OPUT_FLG_ON.equals(ucwkOputFlg))
		{
			// 通信サービス料金内訳リストデータ取得
			getInfoTushinSvcPrcUcwk(handle, param, fixedText, inMap, true);

			// CSV編集処理
			byte[] csvData = makeCSVDataTushinSvcPrcUcwk(param, bothDispMap);

			// 帳票生成処理
			rtnParam = createList(handle, param, csvData, funcCd, CHOHYO_SVCR_NO);
		}

		return rtnParam;
	}

	// ▼▼ 帳票処理 ▼▼

	/**
	 * 帳票生成処理
	 * @param handle
	 * @param param
	 * @param csvData
	 * @param funcCd
	 * @param chohyoTeigiNo
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite createList(SessionHandle handle, 
			IRequestParameterReadWrite param, byte[] csvData, String funcCd, String chohyoTeigiNo) throws Exception
	{
		if(!JPCModelConstant.FUNC_CD_1.equals(funcCd))
		{
			return param;
		}

		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// リクエストパラメータ作成
		HashMap<String, Object> parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		String userId = parentMapCC.get(JCHTushinSvcConstCC.ECC0041A110_USER_ID).toString();

		parentMapCC.put(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_TEIGI_NO, chohyoTeigiNo);
		parentMapCC.put(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE, (byte[])csvData);
		parentMapCC.put(JCHTushinSvcConstCC.ECC0041A110_USER_ID, userId);
		// 帳票形成処理種別："1"（PDF形式）
		parentMapCC.put(JCHTushinSvcConstCC.ECC0041A110_TRAN_SBT, "1");

		/*
		 * 上りマッピング処理
		 */
		paramMap = editInMsg(param);

		/*
		 * ＳＣ呼出実行
		 */
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない。
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		/*
		 * 下りマッピング処理
		 */
		IRequestParameterReadWrite rtnParam = editOutMsg(result, param);

		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)rtnParam.getControlMapData(SCControlMapKeys.RETURN_CODE);

		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}

		return rtnParam;
	}

	/**
	 * 帳票生成処理用メッセージ設定処理
	 * @param param
	 * @param csvData
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(MAP_ID);

		CAANMsg template = new CAANMsg(ECC0041A110CBSMsg.class.getName());
		// テンプレートID
		template.set(ECC0041A110CBSMsg.TEMPLATEID, TEMPLATE_ID_ECC0041A110);

		// 機能コード
		template.set(ECC0041A110CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 検索処理パターン
		template.setNull(ECC0041A110CBSMsg.SEARCH_TYPE);

		// 最大検索件数
		template.setNull(ECC0041A110CBSMsg.MAX_SEARCH_NUM);

		// 表示件数
		template.setNull(ECC0041A110CBSMsg.DISPLAY_NUM);

		// 表示ページ番号
		template.setNull(ECC0041A110CBSMsg.DISPLAY_PAGE_NUM);

		// オペレータID
		template.set(ECC0041A110CBSMsg.OPERATORID, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

		// 運用日付
		template.set(ECC0041A110CBSMsg.OPERATEDATE, param.getControlMapData(SCControlMapKeys.OPE_DATE));

		// 運用日時
		template.set(ECC0041A110CBSMsg.OPERATEDATETIME,  param.getControlMapData(SCControlMapKeys.OPE_TIME));


		// ◇業務データの設定
		// 帳票定義体の電子ファイル管理番号
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_TEIGI_NO))) 
		{
			template.setNull(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO, inMap.get(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_TEIGI_NO));
		}
		
		// データファイルの電子ファイル管理番号
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE_NO))) 
		{
			template.setNull(ECC0041A110CBSMsg.DATA_FILE_NO);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.DATA_FILE_NO, inMap.get(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE_NO));
		}
		
		// データファイル
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE))) 
		{
			template.setNull(ECC0041A110CBSMsg.DATA_FILE);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.DATA_FILE, inMap.get(JCHTushinSvcConstCC.ECC0041A110_DATA_FILE));
		}

		// ユーザーID
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_USER_ID))) 
		{
			template.setNull(ECC0041A110CBSMsg.USER_ID);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.USER_ID, inMap.get(JCHTushinSvcConstCC.ECC0041A110_USER_ID));
		}
		
		// 処理種別
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_TRAN_SBT))) 
		{
			template.setNull(ECC0041A110CBSMsg.TRAN_SBT);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.TRAN_SBT, inMap.get(JCHTushinSvcConstCC.ECC0041A110_TRAN_SBT));
		}
		// 帳票出力環境識別コード
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_OPUT_ENV_SKBT_CD))) 
		{
			template.setNull(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD, inMap.get(JCHTushinSvcConstCC.ECC0041A110_CHOHYO_OPUT_ENV_SKBT_CD));
		}

		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * 帳票生成処理用メッセージ取得処理
	 * @param msgList
	 * @param param
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsg(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 結果を詰めるマップを取得。
		HashMap<String, Object> dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap<String, Object>)param.getData(MAP_ID);

		if(dataMap == null) 
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		// 検索系 共通部
		dataMap.put(JCHTushinSvcConstCC.ECC0041A110_TOTAL_SEARCH_NUM, parentTemplate.getString("total_search_num"));
		dataMap.put(JCHTushinSvcConstCC.ECC0041A110_TOTAL_PAGE_NUM, parentTemplate.getString("total_page_num"));
		dataMap.put(JCHTushinSvcConstCC.ECC0041A110_SEARCH_ERR_FLG, parentTemplate.getString("search_err_flg"));

		templateArray = parentTemplate.getCAANMsgList(ECC0041A110CBSMsg.ECC0041A110CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("ECC0041A110CBSMsg1List");

		if (dataList == null) 
		{
			dataList = new ArrayList();
		}

		int dataListNum = dataList.size();

		if (templateArray != null) 
		{
			for(int i = 0; i < templateArray.length; i++) 
			{
				CAANMsg childTemplate = templateArray[i];
				if(i >= dataList.size() - dataListNum)
				{
					dataList.add(new HashMap<String, Object>());
				}
				HashMap<String, Object> childMap = (HashMap<String, Object>)dataList.get(i + dataListNum);

				if (childTemplate.isNull(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECC0041A110_OUTPUT_CHOHYO, new byte[0]);
				} 
				else
				{
					//childMap.put("output_chohyo", (byte[])childTemplate.getObject(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO));
					// byte配列の場合は添付ファイルエリアに格納する
					HashMap<Object, Object> map = new HashMap<Object, Object>();
					ArrayList<HashMap> list = (ArrayList)param.getControlMapData(SCControlMapKeys.ATTACHMENT_FILE_DOWN);
					if (list == null)
					{
						list = new  ArrayList<HashMap>();
					}
					
					map.put(AttachmentFileMapKeys.IDENTIFY_CD, MAP_ID);
					map.put(AttachmentFileMapKeys.LIST_NAME, "ECC0041A110CBSMsg1List");
					map.put(AttachmentFileMapKeys.ITEM_NAME, JCHTushinSvcConstCC.ECC0041A110_OUTPUT_CHOHYO);
					map.put(AttachmentFileMapKeys.INDEX, Integer.toString(i));
					map.put(AttachmentFileMapKeys.FILE, childTemplate.getObject(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO));
					list.add(map);
					param.setControlMapData(SCControlMapKeys.ATTACHMENT_FILE_DOWN, list);
				}


				if (childTemplate.isNull(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM)) 
				{
					childMap.put(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM, JACStrConst.KARA_MOJI);
				} 
				else 
				{
					childMap.put(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM, childTemplate.getString(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM));
				}
				
				if (childTemplate.isNull(ECC0041A110CBSMsg1List.SEND_RESULT_CD)) 
				{
					childMap.put(ECC0041A110CBSMsg1List.SEND_RESULT_CD, JACStrConst.KARA_MOJI);
				} 
				else 
				{
					childMap.put(ECC0041A110CBSMsg1List.SEND_RESULT_CD, childTemplate.getString(ECC0041A110CBSMsg1List.SEND_RESULT_CD));
				}
			}
		}
		dataMap.put("ECC0041A110CBSMsg1List", dataList);

		// エラー情報の設定
		IRequestParameterReadWrite rtnParam = editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)rtnParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		rtnParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		return rtnParam;
	}
	// ▲▲ 帳票処理 ▲▲


	// ▼▼ 通信サービス料金内訳リスト出力関連処理 ▼▼

	/**
	 * 通信サービス料金帳票マップに指定されたキー情報を基に
	 * 【通信サービス料金請求書】情報を取得します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite getInfoTushinSvcPrcSeiky(SessionHandle handle, IRequestParameterReadWrite param,
			String fixedText, HashMap<String, Object> chohyoReqMap) throws Exception
	{

		/* ◇請求契約一意照会サービスインターフェイス */
		execEKK0491A010(handle, param, chohyoReqMap);

		/* ◇判定：請求契約情報 */
		if (isExistSeikyKeiInfo(param))
		{
			/* ◇請求一意照会サービスインターフェイス */
			execECH0051A010(handle, param, chohyoReqMap);

			/* ◇請求内訳一覧照会サービスインターフェイス */
			execECH0101B010(handle, param, chohyoReqMap, false);

			/* ◇請求一意照会サービスインターフェイス */
			String reHakkoMotoSeikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
			if (!JCRUtilCommon.isNull(reHakkoMotoSeikyNo))
			{
				// 窓口の場合、再発行元の請求データ（前受金充当額存在フラグ）を取得する。
				execECH0051A010_2(handle, param, chohyoReqMap, reHakkoMotoSeikyNo);
			}
		}

		return param;
	}

	// ANK-3838-00-00 ADD START
	/**
	 * 通信サービス料金帳票マップに指定されたキー情報を基に
	 * 請求書(窓口／コンビニ・パーフェクト)情報を取得します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite getInfoSeikyshoMadoConvPerf(SessionHandle handle, IRequestParameterReadWrite param,
			String fixedText, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		/* ◇請求契約一意照会サービスインターフェイス */
		execEKK0491A010(handle, param, chohyoReqMap);
		
		/* ◇判定：請求契約情報 */
		if (isExistSeikyKeiInfo(param))
		{
			/* ◇請求一意照会サービスインターフェイス */
			execECH0051A010(handle, param, chohyoReqMap);
			
			/* ◇請求内訳一覧照会サービスインターフェイス */
			execECH0101B010(handle, param, chohyoReqMap, false);
			
			/* ◇請求一意照会サービスインターフェイス */
			String reHakkoMotoSeikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
			if (!JCRUtilCommon.isNull(reHakkoMotoSeikyNo))
			{
				// 窓口の場合、再発行元の請求データ（前受金充当額存在フラグ）を取得する。
				execECH0051A010_2(handle, param, chohyoReqMap, reHakkoMotoSeikyNo);
			}
			
			execECH0941A010(handle, param, chohyoReqMap, false);
		}
		
		return param;
	}
	// ANK-3838-00-00 ADD END

	/**
	 * 通信サービス料金帳票マップに指定されたキー情報を基に
	 * 【通信サービス料金口座振替のお知らせ兼領収証】情報を取得します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param chohyoKbn 帳票区分
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite getInfoTushinSvcPrcKoza(SessionHandle handle,
// ANK-4415-00-00 MOD START
//			IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> chohyoReqMap, String chohyoKbn) throws Exception
			IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> chohyoReqMap, String chohyoKbn, String funcCd) throws Exception
// ANK-4415-00-00 MOD END
	{

		/* ◇請求契約一意照会サービスインターフェイス */
		execEKK0491A010(handle, param, chohyoReqMap);

		/* ◇判定：請求契約情報 */
		if (isExistSeikyKeiInfo(param))
		{
			/* ◇請求一意照会サービスインターフェイス */
			execECH0051A010(handle, param, chohyoReqMap);

			/* ◇請求内訳一覧照会サービスインターフェイス */
			execECH0101B010(handle, param, chohyoReqMap, false);

			/* ◇料金スケジュール定義一覧照会サービスインターフェイス */
			execECH0501B020(handle, param, chohyoReqMap, TOGT_FLG);
			
			/* ◇請求一覧照会（請求書料金情報）サービスインターフェイス */
			execECH0051B040(handle, param, chohyoReqMap, chohyoKbn);

			/* ◇料金スケジュール定義一覧照会サービスインターフェイス */
			execECH0501B020(handle, param, chohyoReqMap, ZENGT_FLG);
			
// ANK-4415-00-00 ADD START
			/* ◇入金一覧照会サービスインターフェイス */
			execECH0111B010(handle, param, chohyoReqMap);
			if(JPCModelConstant.FUNC_CD_1.equals(funcCd))
			{
				// 請求額が0以外の場合に次回口座振替日取得処理を実行する
				String amnt = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT);
				if(!"0".equals(amnt))
				{
					/* ◇次回口座振替日取得処理 */
					if(!getNextKhriDay(handle, param, chohyoReqMap))
					{
						// エラーフラグを設定して処理を終了する。
						HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(fixedText);
						ccMsg.put("err_flg", "KHRIDAY_STKU_ERR");
						editErrInfo(param);
						throw new CCException("サービスコンポーネントエラー", new Exception());
					}
				}
			}
// ANK-4415-00-00 ADD END
		}

		return param;
	}

// ANK-4415-00-00 ADD START
	/**
	 * エラー情報を設定します。
	 * @param iparam IRequestParameterReadWrite
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrInfo(IRequestParameterReadWrite iparam) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, JPCModelConstant.RELATION_ERR, JPCModelConstant.NORMAL_END);
		
		// エラー情報のリストを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		HashMap<String, Object> errorMap = new HashMap<String, Object>();
		HashMap<String, String> errorMapChild = new HashMap<String, String>();
		
		errorMap.put(ErrorInfoMapKeys.RETURN_CODE, JPCModelConstant.NORMAL_END);
		errorMap.put(ErrorInfoMapKeys.STATUS, JPCModelConstant.RELATION_ERR);
		
		errorMap.put(ErrorInfoMapKeys.ITEM_CHECK_ERRORS, errorMapChild);
		
		errList.add(errorMap);
		
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, errList);
		
		return param;
	}

	/**
	 * コントロールマップエラー情報格納処理を行います。
	 * @param param リクエストパラメータ
	 * @param itemplateStatus サービスインターフェイスステータス
	 * @param returnCode リターンコード
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite setControlMapErrInfo(IRequestParameterReadWrite param, int itemplateStatus, int returnCode)
	throws RequestParameterException
	{
		int templateStatus = itemplateStatus;
		if(returnCode != 0)
		{
			templateStatus = 9000;
		}

		if(JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if(templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		return param;
	}
// ANK-4415-00-00 ADD END

	/**
	 * 通信サービス料金帳票マップに指定されたキー情報を基に
	 * 【通信サービス料金のお知らせ】情報を取得します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite getInfoTushinSvcPrcInfo(SessionHandle handle, 
			IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> chohyoReqMap) throws Exception
	{

		/* ◇請求契約一意照会サービスインターフェイス */
		execEKK0491A010(handle, param, chohyoReqMap);

		/* ◇判定：請求契約情報 */
		if (isExistSeikyKeiInfo(param))
		{
			/* ◇請求一意照会サービスインターフェイス */
			execECH0051A010(handle, param, chohyoReqMap);

			/* ◇請求内訳一覧照会サービスインターフェイス */
			execECH0101B010(handle, param, chohyoReqMap, false);
		}

		return param;
	}

	/**
	 * 通信サービス料金帳票マップに指定されたキー情報を基に【通信サービス料金内訳書】情報を取得します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param reHakko 再発行フラグ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite getInfoTushinSvcPrcUcwk(SessionHandle handle, 
			IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> chohyoReqMap, boolean reHakko) throws Exception
	{

		/* ◇請求契約一意照会サービスインターフェイス */
		execEKK0491A010(handle, param, chohyoReqMap);

		/* ◇判定：請求契約情報 */
		if (isExistSeikyKeiInfo(param))
		{
			if (reHakko)
			{
				// 再発行データ登録時、再発行元の請求内訳を出力する。
				String reHakkoMotoSeikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
				if(reHakkoMotoSeikyNo != null && !JACStrConst.KARA_MOJI.equals(reHakkoMotoSeikyNo))
				{
					chohyoReqMap.put(JCHTushinSvcConstCC.ECH0051A010_KEY_SEIKY_NO, reHakkoMotoSeikyNo);
				}
			}

			/* ◇請求一意照会サービスインターフェイス */
			execECH0051A010(handle, param, chohyoReqMap);

			/* ◇請求内訳一覧照会サービスインターフェイス */
			execECH0101B010(handle, param, chohyoReqMap, true);

			// ANK-4401-00-00 ADD START
			/* ◇システムパラメータ管理一意照会サービスインターフェイス */
			execEZM0311A010(handle, param, chohyoReqMap);
			// ANK-4401-00-00 ADD END
		}

		return param;
	}

	/**
	 * 通信サービス料金内訳リスト出力処理チェック処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException RequestParameterException
	 */
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, 
				IRequestParameterReadWrite param, String fixedText) throws RequestParameterException 
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 請求契約一意照会サービスIF用メッセージ設定処理
		ArrayList<CAANMsg> templateEKK0491A010 = editInMsgEKK0491A010(param, paramMap);

		for (CAANMsg msg : templateEKK0491A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

// ANK-4415-00-00 ADD START
	/**
	 * 当月の請求年月を基に次回口座振替年月日を取得します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public boolean getNextKhriDay(SessionHandle handle, 
			IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		// 請求契約番号
		String seikyKeiNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO);
		// 通信サービス料金帳票マップ
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// 料金スケジュール定義一意照会&口座一覧照会呼び出し
		// 請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM);
		// 料金スケジュール定義一意照会
		String eventCd1 = "03";
		CAANMsg ECH0501A010Msg1 = execECH0501A010(handle, param, chohyoReqMap, seikyYm, eventCd1);
		
		// 対象の請求年月の料金計算日が取得できなかった場合
		if(ECH0501A010Msg1.getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST) == null
			|| ECH0501A010Msg1.getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST).length == 0)
		{
			return false;
		}
		
		// 料金スケジュール定義一意照会実行結果を取得し、outList1の空白データに置き換える
		CAANMsg[] ECH0501A010list1 = ECH0501A010Msg1.getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST);
		
		// 料金スケジュール定義一意照会で取得した料金計算日
		String eventYmd = ECH0501A010list1[0].getString(ECH0501A010CBSMsg1List.EVENT_YMD);
		// 口座一覧照会（口座支払方法受付区分）
		CAANMsg EKK0501B002Msg = execEKK0501B002(handle, param, chohyoReqMap, seikyKeiNo, eventYmd);
		// 対象の口座データが取得できなかった場合
		if(EKK0501B002Msg.getCAANMsgList(EKK0501B002CBSMsg.EKK0501B002CBSMSG1LIST) == null
			|| EKK0501B002Msg.getCAANMsgList(EKK0501B002CBSMsg.EKK0501B002CBSMSG1LIST).length == 0)
		{
			return false;
		}
		
		// 口座一覧照会実行結果を取得する
		CAANMsg[] EKK0501B002list = EKK0501B002Msg.getCAANMsgList(EKK0501B002CBSMsg.EKK0501B002CBSMSG1LIST);
		// 口座支払方法受付区分が1の場合、料金スケジュール定義一意照会を実行して口座振替日ＣＰを取得する。
		String kozaPayWayUkDiv = (String)EKK0501B002list[0].getMsgData().get("koza_payway_uk_div");
		if("2".equals(kozaPayWayUkDiv))
		{
			return true;
		}
		else if(!("1".equals(kozaPayWayUkDiv) || "2".equals(kozaPayWayUkDiv)))
		{
			return false;
		}

		// 取得した口座番号もしくは通帳番号が請求一意情報のものと一致していない場合
		String seikyWayCd = (String)dataMap.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_WAY_CD);
		if(!((("2".equals(seikyWayCd))
			&& (((String)dataMap.get(JCHTushinSvcConstCC.ECH0051A010_KOFURI_KOZA_NO))
				.equals((String)EKK0501B002list[0].getMsgData().get("koza_no")))
					|| (("3".equals(seikyWayCd))
						&& (((String)dataMap.get(JCHTushinSvcConstCC.ECH0051A010_KOFURI_TSUCHO_NO))
							.equals((String)EKK0501B002list[0].getMsgData().get("tsucho_no"))))))
		)
		{
			return false;
		}
		
		// 料金スケジュール定義一意照会
		String eventCd2 = "41";
		CAANMsg ECH0501A010Msg2 = execECH0501A010(handle, param, chohyoReqMap, seikyYm, eventCd2);
		// 対象の請求年月の口座振替日ＣＰが取得できなかった場合
		if(ECH0501A010Msg2.getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST) == null
			|| ECH0501A010Msg2.getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST).length == 0)
		{
			return false;
		}

		// 取得したイベント年月日
		CAANMsg[] ECH0501A010Msg1List = ECH0501A010Msg2.getCAANMsgList(ECH0501A010CBSMsg.ECH0501A010CBSMSG1LIST);
		String eventYmd2 = ECH0501A010Msg1List[0].getString(ECH0501A010CBSMsg1List.EVENT_YMD);
		// 業務データ設定
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}
		// 通信サービス料金マップ.料金スケジュール定義一意照会明細.イベント年月日 ← 料金スケジュール定義一意照会明細.イベント年月日
		dataMap.put(JCHTushinSvcConstCC.ECH0501B020_EVENT_YMD, eventYmd2);
		return true;
	}
// ANK-4415-00-00 ADD END
	// ▼▼ サービスIF呼び出し ▼▼

	/**
	 * 請求契約一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0491A010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0491A010 = editInMsgEKK0491A010(param, chohyoReqMap);
		for (CAANMsg msg : templateEKK0491A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0491A010(result, param);
	}

	/**
	 * 請求一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0051A010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0051A010 = editInMsgECH0051A010(param, chohyoReqMap);
		for (CAANMsg msg : templateECH0051A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0051A010(result, param);
	}

	/**
	 * 請求一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param keySeikyNo 請求番号
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0051A010_2(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> chohyoReqMap, String keySeikyNo) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0051A010 = editInMsgECH0051A010_2(param, chohyoReqMap, keySeikyNo);
		for (CAANMsg msg : templateECH0051A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0051A010_2(result, param);
	}

	/**
	 * 請求内訳一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0101B010(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> chohyoReqMap, boolean isUcwkListPrint) throws Exception
	{
		//ANK-4468-00-00 ADD START
		//料金グループ計の文言変更を行う判定をするため、明細行も取得する。
		if(isUcwkListPrint)
		{
			//ANK-4468-00-03 MOD START
//			execECH0101B010(handle, param, chohyoReqMap, false, "");
			execECH0101B010(handle, param, chohyoReqMap, true, "");
			//ANK-4468-00-03 MOD START
		}
		else
		{
			//請求内訳データの明細行と合計行の取得判定を行うために、フラグを追加。
			execECH0101B010(handle, param, chohyoReqMap, true, "1");
			execECH0101B010(handle, param, chohyoReqMap, false, "");
		}
	}
	
	/**
	 * 請求内訳一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @param flg 料金グループ計の文言変更判定用のリストに出力するフラグ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0101B010(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> chohyoReqMap, boolean isUcwkListPrint, String flg) throws Exception
	{
		//ANK-4468-00-00 ADD END
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0101B010 = editInMsgECH0101B010(param, chohyoReqMap, isUcwkListPrint);
		for (CAANMsg msg : templateECH0101B010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		//ANK-4468-00-00 MOD START
//		editOutMsgECH0101B010(result, param);
		editOutMsgECH0101B010(result, param, flg);
		//ANK-4468-00-00 MOD END
	}

	// ANK-3838-00-00 ADD START
	/**
	 * パーフェクト口座一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0941A010(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> chohyoReqMap, boolean isUcwkListPrint) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		
		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();
		
		// 上りマッピング
		ArrayList<CAANMsg> templateECH0941A010 = editInMsgECH0941A010(param, chohyoReqMap);
		for (CAANMsg msg : templateECH0941A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// 下りマッピング
		editOutMsgECH0941A010(result, param);
	}
	// ANK-3838-00-00 ADD END

	/**
	 *料金スケジュール定義一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param flg 
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0501B020(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String
							, Object> chohyoReqMap, String flg) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0501B020 = editInMsgECH0501B020(param, chohyoReqMap, flg);
		for (CAANMsg msg : templateECH0501B020)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0501B020(result, param, flg);
	}

	/**
	 * 請求一覧照会（請求書料金情報）サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @param chohyoKbn 帳票区分
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0051B040(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> chohyoReqMap, String chohyoKbn) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0051B040 = editInMsgECH0051B040(param, chohyoReqMap, chohyoKbn);
		for (CAANMsg msg : templateECH0051B040)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0051B040(result, param);
	}

	/**
	 * 業務パラメータ管理一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEZM0321A010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		// 内訳両出力の業務パラメータ設定値を取得し、inMapにセットする。
		// 上りマッピングの処理結果を取得するためのマップを生成
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// SC実行結果を格納するマップ
		Map<?, ?> result = null;

		// サービスI/F実行するサービスを生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// 上りマッピング
		paramMap = editInMsgEZM0321A010(param);

		// ＳＣ呼出実行
		result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEZM0321A010(result, param, chohyoReqMap);
	}

	//ANK-4418-00-00 ADD START
	/**
	 * 業務パラメータ管理一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEZM0321A010_2(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		// 内訳両出力の業務パラメータ設定値を取得し、inMapにセットする。
		// 上りマッピングの処理結果を取得するためのマップを生成
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// SC実行結果を格納するマップ
		Map<?, ?> result = null;

		// サービスI/F実行するサービスを生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// 上りマッピング
		paramMap = editInMsgEZM0321A010_2(param);

		// ＳＣ呼出実行
		result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEZM0321A010_2(result, param, chohyoReqMap);
	}
	//ANK-4418-00-00 ADD END

	/**
	 * 料金項目抽出変換一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0401B010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		// 業務パラメータ格納用マップを生成
		HashMap<String, String> wkParaMap = createWkParaMap(chohyoReqMap);

		// 業務機能識別コードを保持する配列
		String[] wkSkbtCdArray = new String[WORK_KINO_SKBTCD_LENGTH];

		wkSkbtCdArray[0] = (String)wkParaMap.get(WK_PARA_ID1);
		wkSkbtCdArray[1] = JACStrConst.WKS_CH_SKY_U_NON;

		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		paramMap = editInMsgECH0401B010(param, wkSkbtCdArray);

		// SC実行結果を格納するマップ
		Map<?, ?> result = null;

		// サービスI/F実行するサービスを生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		result = scCall.run(paramMap, handle);
		editOutMsgECH0401B010(result, param, chohyoReqMap);
	}

	//ANK-4401-00-00 ADD START
	/**
	 * 
	 * システムパラメータ管理一意照会サービスインタフェイスを実行する<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private void execEZM0311A010(SessionHandle handle,
									IRequestParameterReadWrite param,
									HashMap<String, Object> chohyoReqMap) throws Exception {
		
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEZM0311A010 = editInMsgEZM0311A010(param, chohyoReqMap);
		
		for (CAANMsg msg : templateEZM0311A010) {
			templateList.add(msg);
		}
		
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEZM0311A010(result, param);
	}
	// ANK-4401-00-00 ADD END
	// ANK-4415-00-00 ADD START
	/**
	 *入金一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0111B010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String
							, Object> chohyoReqMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0111B010 = editInMsgECH0111B010(param, chohyoReqMap);
		for (CAANMsg msg : templateECH0111B010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0111B010(result, param);
	}
	
	/**
	 *料金スケジュール定義一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private CAANMsg execECH0501A010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String
							, Object> chohyoReqMap, String seikyYm, String eventCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0501A010 = editInMsgECH0501A010(param, chohyoReqMap, seikyYm, eventCd);
		for (CAANMsg msg : templateECH0501A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates2 = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates2[0];
		
		// リターンコード取得
		Object return_code = result.get(JCMConstants.RET_CD_INT_KEY);
		
		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		// 例外通知
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return parentTemplate;
	}

	/**
	 *口座一覧照会（口座支払方法受付区分）サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private CAANMsg execEKK0501B002(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String
							, Object> chohyoReqMap, String seikyKeiNo, String eventYmd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0501B002 = editInMsgEKK0501B002(param, chohyoReqMap, seikyKeiNo, eventYmd);
		for (CAANMsg msg : templateEKK0501B002)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates2 = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates2[0];
		
		// リターンコード取得
		Object return_code = result.get(JCMConstants.RET_CD_INT_KEY);
		
		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));

		// 例外通知
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return parentTemplate;
	}
	// ANK-4415-00-00 ADD END
	// ANK-4475-00-00 ADD START
	/**
	 * 料金項目出力名称一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0391A010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap,
			String prcGrpCd, String pcrsCd, String prcSvcCd, String prcKmkCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0391A010 = editInMsgECH0391A010(param, chohyoReqMap, prcGrpCd, pcrsCd, prcSvcCd, prcKmkCd);
		for (CAANMsg msg : templateECH0391A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0391A010(result, param);
	}
	// ANK-4475-00-00 ADD END

	
	// ▲▲ サービスIF呼び出し ▲▲

	// ▼▼ サービスIF用メッセージ設定処理 ▼▼

	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEKK0491A010(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0491A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				EKK0491A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0491A010, EKK0491A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0491A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号
		String seikyKeiNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO);
		if (chohyoReqMap == null || seikyKeiNo == null || JACStrConst.KARA_MOJI.equals(seikyKeiNo))
		{
			template.setNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);
		}

		// NULL → ＫＥＹ＿世代登録年月日時分秒
		template.setNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM);

		// 部品呼び出し → ＫＥＹ＿予約適用年月日
		template.set(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD, com.fujitsu.futurity.bp.custom.common.JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

		templateList.add(template);

		return templateList;
	}

	/**
	 * 請求一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0051A010(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0051A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0051A010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0051A010, ECH0051A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0051A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 請求番号 → 帳票出力依頼リストマップ.ＫＥＹ＿請求番号
		String scName = (String)chohyoReqMap.get("sc_name");
		if(scName == null || JACStrConst.KARA_MOJI.equals(scName))
		{
			// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → ＫＥＹ＿請求番号
			template.set(ECH0051A010CBSMsg.KEY_SEIKY_NO, (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_SEIKY_NO));
		}
		else
		{
			// 部品呼び出し → ＫＥＹ＿請求番号
			template.set(ECH0051A010CBSMsg.KEY_SEIKY_NO, com.fujitsu.futurity.bp.custom.common.JCHBPCommon.getBPItemValueString(param, scName, "seiky_no"));
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 請求一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param keySeikyNo 請求番号
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0051A010_2(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap, String keySeikyNo) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0051A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0051A010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0051A010, ECH0051A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0051A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 請求番号 → 帳票出力依頼リストマップ.ＫＥＹ＿請求番号
		// 入力パラメータ → ＫＥＹ＿請求番号
		template.set(ECH0051A010CBSMsg.KEY_SEIKY_NO, keySeikyNo);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0101B010(IRequestParameterReadWrite param, 
			HashMap<String, Object> chohyoReqMap, boolean isUcwkListPrint) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0101B010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0101B010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0101B010, ECH0101B010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0101B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → 請求内訳一覧照会マップ.ＫＥＹ＿請求番号
		String seikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_NO);
		if (chohyoReqMap == null || seikyNo == null || JACStrConst.KARA_MOJI.equals(seikyNo))
		{
			HashMap<String, Object> inMap2 = (HashMap<String, Object>)param.getData("CHSV004302SC");
			if(inMap2 == null || inMap2.get("seiky_no") == null || JACStrConst.KARA_MOJI.equals((String)inMap2.get("seiky_no")))
			{
				template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_NO);
			} 
			else 
			{
				template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, (String)inMap2.get("seiky_no"));
			}
		} 
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, seikyNo);
		}

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求年月 → 請求内訳一覧照会マップ.ＫＥＹ＿請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM);
		if (chohyoReqMap == null || seikyYm == null || JACStrConst.KARA_MOJI.equals(seikyYm))
		{
			template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_YM);
		}
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_YM, seikyYm);
		}

		// "CH" → 請求内訳一覧照会マップ.ＫＥＹ＿システムコード
		template.set(ECH0101B010CBSMsg.KEY_SYS_CD, JACStrConst.SYS_CD_CH);

		// 請求内訳一覧照会マップ.ＫＥＹ＿業務機能識別コード
		if(LIST_KBN_SVCR.equals(inMap.get("chohyo_kbn")) || isUcwkListPrint == true)
		{
			template.set(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD, WORK_KINO_SKBT_SEIKY_UCHWK);
		}
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD, WORK_KINO_SKBT_SEIKY_UCHWK_GKI);
		}

		// "1" → 請求内訳一覧照会マップ.料金項目名称種別コード
		template.set(ECH0101B010CBSMsg.KEY_PRC_KMK_NM_SBT_CD, JACStrConst.PRC_KMK_NM_SBT_CD_PRC_NM);

		// 通信サービス料金帳票マップ.請求種別コード → 請求内訳一覧照会マップ.ＫＥＹ＿請求種別コード
		String seikySbtCd = (String)inMap.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_SBT_CD);
		if (inMap == null || seikySbtCd == null || JACStrConst.KARA_MOJI.equals(seikySbtCd))
		{
			template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_SBT_CD);
		}
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_SBT_CD, seikySbtCd);
		}
		
		// ANK-4401-00-00 ADD START
		// "0" → 請求内訳一覧照会マップ.ＫＥＹ＿契約者名表示制御フラグ
		template.set(ECH0101B010CBSMsg.KEY_KEISYA_NM_DSP_CTRL_FLG, KEISYA_NM_DSP_CTRL_FLG_0);
		// ANK-4401-00-00 ADD END
		
		// ANK-4475-00-00 ADD START
		// "0" → 請求内訳一覧照会マップ.ＫＥＹ＿マンションオーナー向け表示制御フラグ
		template.set(ECH0101B010CBSMsg.KEY_MASION_OWNER_CTRL_FLG, KEY_MASION_OWNER_CTRL_FLG_0);
		// ANK-4475-00-00 ADD END

		templateList.add(template);

		return templateList;
	}

	// ANK-3838-00-00 ADD START
	/**
	 * パーフェクト口座一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0941A010(IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();
		
		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0941A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0101B010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0941A010, ECH0941A010CBSMsg.FUNC_CODE);
		
		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0941A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);
		
		String seikyKeiNo = "";
		if (chohyoReqMap != null)
		{
			// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → パーフェクト口座一意照会マップ.ＫＥＹ＿請求契約番号
			seikyKeiNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO);
			if (seikyKeiNo == null || JACStrConst.KARA_MOJI.equals(seikyKeiNo))
			{
				template.setNull(ECH0941A010CBSMsg.KEY_SEIKY_KEI_NO);
			} 
			else
			{
				template.set(ECH0941A010CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);
			}
		}
		
		templateList.add(template);
		
		return templateList;
	}
	// ANK-3838-00-00 ADD END

	/**
	 * 料金スケジュール定義一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param flg フラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0501B020(IRequestParameterReadWrite param, HashMap<String
						, Object> chohyoReqMap, String flg) throws RequestParameterException, Exception
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0501B020CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0501B020CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0501B020, ECH0501B020CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0501B020CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// "15"固定 → ＫＥＹ＿イベントコード
		template.set(ECH0501B020CBSMsg.KEY_EVENT_CD, JACStrConst.EVENT_CD_KOUZA_HURIKAE_YMD);

		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		// 請求年月
		String seikyYm = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM));

		// 当月請求年月
		if(flg.equals(TOGT_FLG))
		{
			template.set(ECH0501B020CBSMsg.KEY_SEIKY_YM, seikyYm);
		}
		// 前月請求年月
		else
		{

			StringBuffer seikyYmd = new StringBuffer();
			
			// 請求年月末尾に"01"を付加する
			seikyYmd.append(seikyYm);
			seikyYmd.append(JACStrConst.STR_OF_MONTH);
			
			// 前月請求年月の取得
			seikyYm = JPCUtilCommon.addMonth(seikyYmd.toString(), -1).substring(0, 6);
			
			template.set(ECH0501B020CBSMsg.KEY_SEIKY_YM, seikyYm);
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 請求一覧照会（請求書料金情報）サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @param chohyoKbn 帳票区分
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0051B040(IRequestParameterReadWrite param, 
			HashMap<String, Object> chohyoReqMap, String chohyoKbn) throws RequestParameterException, Exception
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0051B040CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0051B040CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0051B040, ECH0051B040CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0051B040CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求契約番号 → 請求内訳一覧照会マップ.ＫＥＹ＿請求契約番号
		String seikyKeiNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051B040_KEY_SEIKY_KEI_NO);
		if (chohyoReqMap == null || seikyKeiNo == null || JACStrConst.KARA_MOJI.equals(seikyKeiNo))
		{
			HashMap<String, Object> inMap2 = (HashMap<String, Object>)param.getData("CHSV004302SC");
			if(inMap2 == null || inMap2.get("seiky_kei_no") == null || JACStrConst.KARA_MOJI.equals((String)inMap2.get("seiky_kei_no")))
			{
				template.setNull(ECH0051B040CBSMsg.KEY_SEIKY_KEI_NO);
			}
			else
			{
				template.set(ECH0051B040CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap2.get("seiky_kei_no"));
			}
		}
		else
		{
			template.set(ECH0051B040CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);
		}

		// 請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051B040_KEY_SEIKY_YM);
		
		// 帳票区分 = 帳票区分（請求書(口座振替)）の場合
		if(LIST_KBN_KOZA.equals(chohyoKbn))
		{
			// 請求年月の前月を設定する
			seikyYm = JPCUtilCommon.addMonth(seikyYm + "01", -1);
		}
		
		// 帳票出力依頼リストマップ.ＫＥＹ＿請求年月 または ＫＥＹ＿請求年月（前月） → 請求内訳一覧照会マップ.ＫＥＹ＿請求年月
		template.set(ECH0051B040CBSMsg.KEY_SEIKY_YM, seikyYm.substring(0, 6));

		// 通信サービス料金帳票マップ.請求種別コード → 請求一覧照会（請求書料金情報）.ＫＥＹ＿請求種別コード
		template.set(ECH0051B040CBSMsg.KEY_SEIKY_SBT_CD, JACStrConst.SIKYSHBTS_TEIGK_SEIKY);

		// 運用日付 → 請求一覧照会（請求書料金情報）.運用日付
		template.set(ECH0051B040CBSMsg.KEY_UNYO_YMD, com.fujitsu.futurity.bp.custom.common.JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

		// 業務パラメータＩＤ１ → 請求一覧照会（請求書料金情報）.業務パラメータＩＤ１
		template.set(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID1, JACStrConst.WKPARA_CH_CRECARD_FTTH);
		
		// 業務パラメータＩＤ２ → 請求一覧照会（請求書料金情報）.業務パラメータＩＤ２
		template.set(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID2, JACStrConst.WKPRA_CH_WKS_SIKY_AMNT);
		
		// 業務パラメータＩＤ３ → 請求一覧照会（請求書料金情報）.業務パラメータＩＤ３
		template.set(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID3, JACStrConst.WKPRA_CH_WKS_SAIKEN_U_STAX);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 料金項目抽出変換一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editInMsgECH0401B010(IRequestParameterReadWrite param, String[] wkSkbtCdArray) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		int wkParamCnt = wkSkbtCdArray.length;

		// テンプレート配列の作成
		CAANMsg[] templates = new CAANMsg[wkParamCnt];

		// 業務パラメータ数分繰り返す
		for (int i = 0; i < wkParamCnt; i++)
		{
			// 業務機能識別コードを取得
			String wkSkbtCd = wkSkbtCdArray[i];

			// テンプレートを作成
			CAANMsg template = new CAANMsg(ECH0401B010CBSMsg.class.getName());

			// テンプレートID
			template.set(ECH0401B010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0401B010);

			// 機能コード
			template.set(ECH0401B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

			// オペレータID
			template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

			// 運用日付
			template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));

			// 運用日時
			template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));

			// システムコード → システムコード
			template.set(ECH0401B010CBSMsg.KEY_SYS_CD, JACStrConst.SYS_CD_CH);
			
			// 業務機能識別コード → 請求内訳一覧照会.業務機能識別コード
			template.set(ECH0401B010CBSMsg.KEY_WORK_KINO_SKBT_CD, wkSkbtCd);
			
			// 抽出変換コード → 抽出変換コード(抽出のみ)
			template.set(ECH0401B010CBSMsg.KEY_CHSHT_CHG_CD, JACStrConst.CHSHT_CHG_CD_CST);

			// null → 料金グループコード
			template.setNull(ECH0401B010CBSMsg.KEY_PRC_GRP_CD);
			
			// null → 料金コースコード
			template.setNull(ECH0401B010CBSMsg.KEY_PCRS_CD);

			// テンプレート配列にテンプレートを格納
			templates[i] = template;
		}

		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * 上りマッピング（業務パラメータ管理一意照会）
	 * 
	 * @param param リクエストパラメータ
	 * @param workParamId 業務パラメータＩＤ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEZM0321A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		// テンプレート配列の作成
		CAANMsg[] templates = new CAANMsg[WK_PARA_IDS.length];
		
		// 業務パラメータ数分繰り返す
		for (int i = 0; i < WK_PARA_IDS.length; i++)
		{
			// 業務パラメータを取得
			String wkParaId = WK_PARA_IDS[i];

			// テンプレートを作成
			CAANMsg template = new CAANMsg(EZM0321A010CBSMsg.class.getName());

			// テンプレートID
			template.set(EZM0321A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0321A010);

			// 機能コード
			template.set(EZM0321A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

			// オペレータID
			template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

			// 運用日付
			template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));

			// 運用日時
			template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));

			// 業務パラメータＩＤ → 業務パラメータ管理一意照会.業務パラメータＩＤ
			if (JCRUtilCommon.isNull(wkParaId))
			{
				template.setNull(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID);
			}
			else
			{
				template.set(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, wkParaId);
			}
		
			// テンプレート配列にテンプレートを格納
			templates[i] = template;
		}
		
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	// ANK-4401-00-00 ADD START
	/**
	 * システムパラメータ管理一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEZM0311A010(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EZM0311A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				EZM0311A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0311A010, EZM0311A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EZM0311A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// "INVOICE" → システムパラメータ管理一意照会明細マップ.ＫＥＹ＿システムパラメータ分類コード
		template.set(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD, JACStrConst.SYSPARA_INVOICE);

		// "INV_BUZ_NO" → システムパラメータ管理一意照会明細マップ.ＫＥＹ＿システムパラメータID
		template.set(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID, JACStrConst.ISYSID_NV_BUZ_NO);

		templateList.add(template);

		return templateList;
	}
	// ANK-4401-00-00 ADD END
	// ANK-4415-00-00 ADD START
	/**
	 * 入金一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0111B010(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();
		
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// 請求契約番号
		String seikyKeiNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051B040_KEY_SEIKY_KEI_NO);
		// 前月請求番号
		String seikyNo = (String)dataMap.get(JCHTushinSvcConstCC.ECH0051B040_ZEN_SEIKY_NO);

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0111B010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0111B010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0111B010, ECH0111B010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0111B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_4);
		

		// 請求一覧照会明細マップ.請求契約番号 → 入金一覧照会マップ.ＫＥＹ＿請求契約番号
		template.set(ECH0111B010CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);

		// 請求一覧照会明細マップ.前月請求番号 → 入金一覧照会マップ.ＫＥＹ＿請求番号
		template.set(ECH0111B010CBSMsg.KEY_SEIKY_NO, seikyNo);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 料金スケジュール定義一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0501A010(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap, String seikyYm, String eventCd) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0501A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0501A010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0501A010, ECH0501A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0501A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_6);
		

		// 請求年月日 → 料金スケジュール定義一意照会マップ.ＫＥＹ＿請求年月
		template.set(ECH0501A010CBSMsg.KEY_SEIKY_YM, seikyYm);

		// イベントコード → 料金スケジュール定義一意照会マップ.ＫＥＹ＿イベントコード
		template.set(ECH0501A010CBSMsg.KEY_EVENT_CD, eventCd);

		// 運用日 → 料金スケジュール定義一意照会マップ.ＫＥＹ＿運用日
		template.set(ECH0501A010CBSMsg.KEY_UNYO_DAY, "20991231");

		templateList.add(template);

		return templateList;
	}

	/**
	 * 口座一覧照会（口座支払方法受付区分）サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEKK0501B002(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap, String seikyKeiNo, String eventYmd) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0501B002CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				EKK0501B002CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0501B002, EKK0501B002CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0501B002CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		

		// 請求契約番号 → 口座一覧照会マップ.ＫＥＹ＿請求契約番号
		template.set(EKK0501B002CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);

		// イベント年月日 → 口座一覧照会マップ.ＫＥＹ＿予約適用年月日
		template.set(EKK0501B002CBSMsg.KEY_RSV_APLY_YMD, eventYmd);

		templateList.add(template);

		return templateList;
	}
	// ANK-4415-00-00 ADD END
	
// ANK-4475-00-00 ADD START	
	/**
	 * 料金項目出力名称一意照会用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0391A010(IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap,
			String prcGrpCd, String pcrsCd, String prcSvcCd, String prcKmkCd) throws RequestParameterException 
	{

		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();
		
		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0391A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0391A010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0391A010, ECH0391A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0391A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// 料金グループコード → 料金項目出力名称一意照会マップ.ＫＥＹ＿料金グループコード
		template.set(ECH0391A010CBSMsg.KEY_PRC_GRP_CD, prcGrpCd);
		// 料金コースコード → 料金項目出力名称一意照会マップ.ＫＥＹ＿料金コースコード
		template.set(ECH0391A010CBSMsg.KEY_PCRS_CD, pcrsCd);
		// 料金サービスコード → 料金項目出力名称一意照会マップ.ＫＥＹ＿料金サービスコード
		template.set(ECH0391A010CBSMsg.KEY_PRC_SVC_CD, prcSvcCd);
		// 料金項目コード → 料金項目出力名称一意照会マップ.ＫＥＹ＿料金項目コード
		template.set(ECH0391A010CBSMsg.KEY_PRC_KMK_CD, prcKmkCd);

		templateList.add(template);

		return templateList;
	}

// ANK-4475-00-00 ADD END

	// ▲▲ サービスIF用メッセージ設定処理 ▲▲

	//ANK-4418-00-00 ADD START
	/**
	 * 上りマッピング（業務パラメータ管理一意照会）2
	 * 
	 * @param param リクエストパラメータ
	 * @param workParamId 業務パラメータＩＤ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEZM0321A010_2(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		// テンプレート配列の作成
		CAANMsg[] templates = new CAANMsg[WK_PARA_IDM.length];
		
		// 業務パラメータ数分繰り返す
		for (int i = 0; i < WK_PARA_IDM.length; i++)
		{
			// 業務パラメータを取得
			String wkParaId = WK_PARA_IDM[i];

			// テンプレートを作成
			CAANMsg template = new CAANMsg(EZM0321A010CBSMsg.class.getName());

			// テンプレートID
			template.set(EZM0321A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0321A010);

			// 機能コード
			template.set(EZM0321A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

			// オペレータID
			template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

			// 運用日付
			template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));

			// 運用日時
			template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));

			// 業務パラメータＩＤ → 業務パラメータ管理一意照会.業務パラメータＩＤ
			if (JCRUtilCommon.isNull(wkParaId))
			{
				template.setNull(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID);
			}
			else
			{
				template.set(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, wkParaId);
			}
		
			// テンプレート配列にテンプレートを格納
			templates[i] = template;
		}
		
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	//ANK-4418-00-00 ADD END
// ANK-4595-01-00 ADD START
	/**
	 * 上りマッピング（業務パラメータ管理一意照会）3(電気単独)
	 * 
	 * @param param リクエストパラメータ
	 * @param workParamId 業務パラメータＩＤ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEZM0321A010_3(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		// テンプレート配列の作成
		CAANMsg[] templates = new CAANMsg[WK_PARA_IDM.length];
		
		// 業務パラメータ数分繰り返す
		for (int i = 0; i < WK_PARA_IDM.length; i++)
		{
			// 業務パラメータを取得
			String wkParaId = WK_PARA_IDM[i];

			// テンプレートを作成
			CAANMsg template = new CAANMsg(EZM0321A010CBSMsg.class.getName());

			// テンプレートID
			template.set(EZM0321A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0321A010);

			// 機能コード
			template.set(EZM0321A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

			// オペレータID
			template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

			// 運用日付
			template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));

			// 運用日時
			template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));

			// 業務パラメータＩＤ → 業務パラメータ管理一意照会.業務パラメータＩＤ
			if (JCRUtilCommon.isNull(wkParaId))
			{
				template.setNull(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID);
			}
			else
			{
				template.set(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, wkParaId);
			}
		
			// テンプレート配列にテンプレートを格納
			templates[i] = template;
		}
		
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
// ANK-4595-01-00 ADD END
	// ▼▼ サービスIF用メッセージ取得処理 ▼▼

	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0491A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 通信サービス料金内訳リストマップ.請求契約ステータス ← 請求契約一意照会明細.請求契約ステータス
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_KEI_STAT))
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SEIKY_KEI_STAT, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SEIKY_KEI_STAT, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_KEI_STAT));
				}

				// 通信サービス料金マップ.送付先名 ← 請求契約一意照会明細.送付先名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_NM, new String());
				} 
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_NM));
				}
				// 通信サービス料金マップ.送付先部課名 ← 請求契約一意照会明細.送付先部課名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_BKM))
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BKM, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BKM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_BKM));
				}
				// 通信サービス料金マップ.送付先担当者名 ← 請求契約一意照会明細.送付先担当者名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_TNTSHA_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_TNTSHA_NM, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_TNTSHA_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_TNTSHA_NM));
				}
				// 通信サービス料金マップ.送付先名 ← 請求契約一意照会明細.送付先名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_NM, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_NM));
				}
				// 通信サービス料金マップ.送付先郵便番号 ← 請求契約一意照会明細.送付先郵便番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_PCD))
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_PCD));
				}
				// 通信サービス料金マップ.送付先都道府県名 ← 請求契約一意照会明細.送付先都道府県名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_STATE_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_STATE_NM, new String());
				} 
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_STATE_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_STATE_NM));
				}
				// 通信サービス料金マップ.送付先市区町村名 ← 請求契約一意照会明細.送付先市区町村名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_CITY_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_CITY_NM, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_CITY_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_CITY_NM));
				}
				// 通信サービス料金マップ.送付先大字通称名 ← 請求契約一意照会明細.送付先大字通称名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_OAZTSU_NM)) 
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_OAZTSU_NM, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_OAZTSU_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_OAZTSU_NM));
				}
				// 通信サービス料金マップ.送付先字丁目名 ← 請求契約一意照会明細.送付先字丁目名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_AZCHO_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_AZCHO_NM, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_AZCHO_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_AZCHO_NM));
				}
				// 通信サービス料金マップ.送付先住所補記・建物名 ← 請求契約一意照会明細.送付先住所補記・建物名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_ADRTTM)) 
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRTTM, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRTTM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_ADRTTM));
				}
				// 通信サービス料金マップ.送付先住所補記・部屋番号 ← 請求契約一意照会明細.送付先住所補記・部屋番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_ADRRM)) 
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRRM, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRRM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_ADRRM));
				}
				// 通信サービス料金マップ.送付先番地号 ← 請求契約一意照会明細.送付先番地号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_BNCHIGO)) 
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BNCHIGO, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BNCHIGO, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_BNCHIGO));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * 請求一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0051A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0051A010CBSMsg.ECH0051A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 通信サービス料金マップ.請求年月 ← 請求一意明細.請求年月
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.SEIKY_YM)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM, childTemplate.getString(ECH0051A010CBSMsg1List.SEIKY_YM));
				}
				// 通信サービス料金マップ.請求種別コード ← 請求一意明細.請求種別コード
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.SEIKY_SBT_CD))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_SBT_CD, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_SBT_CD, childTemplate.getString(ECH0051A010CBSMsg1List.SEIKY_SBT_CD));
				}
				// 通信サービス料金マップ.請求方法コード ← 請求一意明細.請求方法コード
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.SEIKY_WAY_CD)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_WAY_CD, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_WAY_CD, childTemplate.getString(ECH0051A010CBSMsg1List.SEIKY_WAY_CD));
				}
				// 通信サービス料金マップ.請求書発行シーケンス ← 請求一意明細.請求書発行シーケンス
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.SKS_HAKKO_SEQ))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SKS_HAKKO_SEQ, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SKS_HAKKO_SEQ, childTemplate.getString(ECH0051A010CBSMsg1List.SKS_HAKKO_SEQ));
				}
				// 通信サービス料金マップ.カスタマーバーコード ← 請求一意明細.カスタマーバーコード
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.CUSTOMER_BARCODE))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_CUSTOMER_BARCODE, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_CUSTOMER_BARCODE, childTemplate.getString(ECH0051A010CBSMsg1List.CUSTOMER_BARCODE));
				}
				// 通信サービス料金マップ.口座振替＿金融機関名 ← 請求一意明細.口座振替＿金融機関名
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.KOFURI_BANK_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_BANK_NM, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_BANK_NM, childTemplate.getString(ECH0051A010CBSMsg1List.KOFURI_BANK_NM));
				}
				// 通信サービス料金マップ.口座振替＿金融機関支店名 ← 請求一意明細.口座振替＿金融機関支店名
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.KOFURI_BANK_SHITEN_NM)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_BANK_SHITEN_NM, new String());
				} 
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_BANK_SHITEN_NM, childTemplate.getString(ECH0051A010CBSMsg1List.KOFURI_BANK_SHITEN_NM));
				}
				// 通信サービス料金マップ.口座振替＿預金種目コード名称 ← 請求一意明細.口座振替＿預金種目コード名称
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.KOFURI_YOKIN_SHUMOKU_CD_NM)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_YOKIN_SHUMOKU_CD_NM, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_YOKIN_SHUMOKU_CD_NM, 
							childTemplate.getString(ECH0051A010CBSMsg1List.KOFURI_YOKIN_SHUMOKU_CD_NM));
				}
				// 通信サービス料金マップ.口座振替＿口座番号 ← 請求一意明細.口座振替＿口座番号
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.KOFURI_KOZA_NO))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_KOZA_NO, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_KOZA_NO, childTemplate.getString(ECH0051A010CBSMsg1List.KOFURI_KOZA_NO));
				}
				// OM-2021-0000584 ADD START
				// 通信サービス料金マップ.口座振替＿金融機関コード ← 請求一意明細.口座振替＿金融機関コード
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.KOFURI_BANK_CD))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_BANK_CD, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_BANK_CD, childTemplate.getString(ECH0051A010CBSMsg1List.KOFURI_BANK_CD));
				}
				// 通信サービス料金マップ.口座振替＿通帳番号 ← 請求一意明細.口座振替＿通帳番号
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.KOFURI_TSUCHO_NO))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_TSUCHO_NO, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_KOFURI_TSUCHO_NO, childTemplate.getString(ECH0051A010CBSMsg1List.KOFURI_TSUCHO_NO));
				}
				// OM-2021-0000584 ADD END
				// 通信サービス料金マップ.クレジット＿クレジット会社名 ← 請求一意明細.クレジット＿クレジット会社名
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.CRECARD_CRECARD_COMP_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_CRECARD_CRECARD_COMP_NM, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_CRECARD_CRECARD_COMP_NM, childTemplate.getString(ECH0051A010CBSMsg1List.CRECARD_CRECARD_COMP_NM));
				}
				// 通信サービス料金マップ.請求書発行年月日 ← 請求一意明細.請求書発行年月日
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.SEIKYUS_HAKKO_YMD)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKYUS_HAKKO_YMD, new String());
				} 
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKYUS_HAKKO_YMD, childTemplate.getString(ECH0051A010CBSMsg1List.SEIKYUS_HAKKO_YMD));
				}
				// 通信サービス料金マップ.請求額 ← 請求一意明細.請求額
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.SEIKY_AMNT))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT, childTemplate.getString(ECH0051A010CBSMsg1List.SEIKY_AMNT));
				}
				// 通信サービス料金マップ.消費税額 ← 請求一意明細.消費税額
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.STAX_AMNT))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_STAX_AMNT, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_STAX_AMNT, childTemplate.getString(ECH0051A010CBSMsg1List.STAX_AMNT));
				}
				// 通信サービス料金マップ.窓口＿OCR番号 ← 請求一意明細.窓口＿OCR番号
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.MADOGUCHI_OCR_NO)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_OCR_NO, new String());
				} 
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_OCR_NO, childTemplate.getString(ECH0051A010CBSMsg1List.MADOGUCHI_OCR_NO));
				}
				// 通信サービス料金マップ.窓口＿ＥＡＮバーコード ← 請求一意明細.窓口＿ＥＡＮバーコード
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.MADOGUCHI_EAN_BARCODE))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_EAN_BARCODE, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_EAN_BARCODE, childTemplate.getString(ECH0051A010CBSMsg1List.MADOGUCHI_EAN_BARCODE));
				}
				// 通信サービス料金マップ.請求抑止フラグ ← 請求一意明細.請求抑止フラグ
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.SEIKY_YOKSI_FLG)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YOKSI_FLG, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YOKSI_FLG, childTemplate.getString(ECH0051A010CBSMsg1List.SEIKY_YOKSI_FLG));
				}
				// 通信サービス料金マップ.合算フラグ ← 請求一意明細.合算フラグ
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.GSAN_FLG)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_GSAN_FLG, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_GSAN_FLG, childTemplate.getString(ECH0051A010CBSMsg1List.GSAN_FLG));
				}
				// 通信サービス料金マップ.前受金充当額存在フラグ ← 請求一意明細.前受金充当額存在フラグ
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.MAEUKE_JUTO_FLG)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_MAEUKE_JUTO_FLG, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_MAEUKE_JUTO_FLG, childTemplate.getString(ECH0051A010CBSMsg1List.MAEUKE_JUTO_FLG));
				}
				// OM-2015-0001907 ADD START
				// 通信サービス料金マップ.請求抑止フラグ（口座番号表示抑止） ← 請求一意明細.請求抑止フラグ（口座番号表示抑止）
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.SEIKY_YOKSI_FLG_KOZA)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YOKSI_FLG_KOZA, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YOKSI_FLG_KOZA, childTemplate.getString(ECH0051A010CBSMsg1List.SEIKY_YOKSI_FLG_KOZA));
				}
				// OM-2015-0001907 ADD END
				// ANK-4401-00-00 ADD START
				// 通信サービス料金マップ.料金変更フラグ ← 請求一意明細.料金変更フラグ
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.PRC_CHG_FLG)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_PRC_CHGE_FLG, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_PRC_CHGE_FLG, childTemplate.getString(ECH0051A010CBSMsg1List.PRC_CHG_FLG));
				}
				// ANK-4401-00-00 ADD END
// ANK-4475-00-00 ADD START
				// 通信サービス料金マップ.卸先事業者コード ← 請求一意明細.卸先事業者コード
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.ORSJGS_CD)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_ORSJGS_CD, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051A010_ORSJGS_CD, childTemplate.getString(ECH0051A010CBSMsg1List.ORSJGS_CD));
				}
// ANK-4475-00-00 ADD END
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * 請求一意照会サービスインターフェイス用メッセージ取得処理(再発行元用)<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0051A010_2(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0051A010CBSMsg.ECH0051A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 通信サービス料金マップ.合算フラグ ← 請求一意明細.合算フラグ
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.GSAN_FLG)) 
				{
					dataMap.put(JCHTushinSvcConstCC.REHAKKO_MOTO_GSAN_FLG, "");
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.REHAKKO_MOTO_GSAN_FLG, childTemplate.getString(ECH0051A010CBSMsg1List.GSAN_FLG));
				}

				// 通信サービス料金マップ.前受金充当額存在フラグ ← 請求一意明細.前受金充当額存在フラグ
				if (childTemplate.isNull(ECH0051A010CBSMsg1List.MAEUKE_JUTO_FLG)) 
				{
					dataMap.put(JCHTushinSvcConstCC.REHAKKO_MOTO_MAEUKE_JUTO_FLG, "");
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.REHAKKO_MOTO_MAEUKE_JUTO_FLG, childTemplate.getString(ECH0051A010CBSMsg1List.MAEUKE_JUTO_FLG));
				}

			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param flg 料金グループ計の文言変更判定用のリストに出力するフラグ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	//ANK-4468-00-00 MOD START	
	//private IRequestParameterReadWrite editOutMsgECH0101B010(Map<?, ?> msgList,
	//		IRequestParameterReadWrite param) throws Exception

	private IRequestParameterReadWrite editOutMsgECH0101B010(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String flg) throws Exception
	//ANK-4468-00-00 MOD END
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		ArrayList dataList = null;

		templateArray = parentTemplate.getCAANMsgList(ECH0101B010CBSMsg.ECH0101B010CBSMSG1LIST);

		//ANK-4468-00-00 ADD START
		if(flg.equals("1"))
		{
			//請求内訳データ明細行データリスト
			dataList = (ArrayList)dataMap.get("ECH0101B010CBSMsg1List_2");
		}
		else
		{
		//ANK-4468-00-00 ADD END
			dataList = (ArrayList)dataMap.get("ECH0101B010CBSMsg1List");
		//ANK-4468-00-00 ADD START
		}
		//ANK-4468-00-00 ADD END

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

// DELETE START 2013.11.18 ANK-1750-00-00
//		// 整理番号マップ（整理番号の表示非表示の制御に使用）
//		HashMap<String, String> seiriNoMap = new HashMap<String, String>();
// DELETE END 2013.11.18 ANK-1750-00-00

		int uwSize = templateArray.length;

		if (templateArray != null)
		{
			//ANK-4468-00-00 ADD START
			//シンプルプランID計の判定
			ArrayList childList2 = (ArrayList)dataMap.get("ECH0101B010CBSMsg1List_2");
			boolean prcKmkNmFlg = false;
			if(!JKKStringUtil.isNullEmpty(childList2))
			{
				ArrayList<String> simpleWorkParamSetteValue = simpleIdWorkParamValueList(param);
			
				for (int i = 0; i < childList2.size(); i++)
				{
					
					HashMap<String, String> dataMap2 = (HashMap<String, String>) childList2.get(i);
					
					StringBuffer str_Buff = new StringBuffer();
					
					str_Buff.append(dataMap2.get("prc_grp_cd"));
					str_Buff.append(",");
					str_Buff.append(dataMap2.get("pcrs_cd"));
					str_Buff.append(",");
					str_Buff.append(dataMap2.get("prc_svc_cd"));
					str_Buff.append(",");
					str_Buff.append(dataMap2.get("prc_kmk_cd"));
					
					String cdJoin = str_Buff.toString();
					
					// シンプルプランID計の業務パラメータ設定値が請求内訳の料金グループコード、料金コースコード、料金サービスコード、料金項目コードと一致する場合
					if (simpleWorkParamSetteValue.contains(cdJoin))
					{
						//シンプルプランＩＤ計判定フラグ
						prcKmkNmFlg = true;
						break;
					}
				}
			}
			//ANK-4468-00-00 ADD END

			for (int i = 0; i < uwSize; i++) 
			{
				CAANMsg childTemplate = templateArray[i];
				if (i >= dataList.size()) 
				{
					dataList.add(new HashMap());
				}
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);

				/*---< #81816 Add start >---*/
				// 通信サービス料金マップ.請求内訳一覧明細.請求年月 ← 請求内訳一覧明細.請求年月
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.SEIKY_YM)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SEIKY_YM, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SEIKY_YM, childTemplate.getString(ECH0101B010CBSMsg1List.SEIKY_YM));
				}
				/*---< #81816 Add end >---*/
				
				// 通信サービス料金マップ.請求内訳一覧明細.サービス契約番号 ← 請求内訳一覧明細.サービス契約番号
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.SVC_KEI_NO)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SVC_KEI_NO, new String());
				}
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SVC_KEI_NO, childTemplate.getString(ECH0101B010CBSMsg1List.SVC_KEI_NO));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.金額 ← 請求内訳一覧明細.金額
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.AMNT)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT, new String());
				} 
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT, childTemplate.getString(ECH0101B010CBSMsg1List.AMNT));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.利用開始年月日 ← 請求内訳一覧明細.利用開始年月日
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.USE_STAYMD))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_USE_STAYMD, new String());
				} 
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_USE_STAYMD, childTemplate.getString(ECH0101B010CBSMsg1List.USE_STAYMD));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.利用終了年月日 ← 請求内訳一覧明細.利用終了年月日
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.USE_ENDYMD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_USE_ENDYMD, new String());
				} 
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_USE_ENDYMD, childTemplate.getString(ECH0101B010CBSMsg1List.USE_ENDYMD));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.料金グループコード ← 請求内訳一覧明細.料金グループコード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PRC_GRP_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_GRP_CD));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.料金コースコード ← 請求内訳一覧明細.料金コースコード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PCRS_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PCRS_CD));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.料金サービスコード ← 請求内訳一覧明細.料金サービスコード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PRC_SVC_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_SVC_CD));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.料金項目コード ← 請求内訳一覧明細.料金項目コード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PRC_KMK_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_KMK_CD));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.料金項目名称 ← 請求内訳一覧明細.料金項目名称
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PRC_KMK_NM)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM, new String());
				}
				else 
				{
					//ANK-4468-00-00 ADD START
					//シンプルプラングループ計特定
					ArrayList<String> simpleGroupKeiWorkParamSetteValue = simpleGroupKeiWorkParamValueList(param);
					String simpleRePrcKmkNm1 = simplePlanRePrcKmkNm(param);
					
					//ANK-4468-00-02 MOD START
//					if (prcKmkNmFlg == true)
					if(prcKmkNmFlg && !JKKStringUtil.isNullEmpty(simpleRePrcKmkNm1))
					//ANK-4468-00-02 MOD END
					{
						StringBuffer str_Buff = new StringBuffer();

						str_Buff.append(childTemplate.getString(ECH0101B010CBSMsg1List.PRC_GRP_CD));
						str_Buff.append(",");
						str_Buff.append(childTemplate.getString(ECH0101B010CBSMsg1List.PCRS_CD));
						str_Buff.append(",");
						str_Buff.append(childTemplate.getString(ECH0101B010CBSMsg1List.PRC_SVC_CD));
						str_Buff.append(",");
						str_Buff.append(childTemplate.getString(ECH0101B010CBSMsg1List.PRC_KMK_CD));
						
						String cdJoin2 = str_Buff.toString();
						
						if (simpleGroupKeiWorkParamSetteValue.contains(cdJoin2))
						{
							/** インデントの編集 */
							String strIndCnt = childTemplate.getString(ECH0101B010CBSMsg1List.INDENT_CNT);
							
							int iIndent = 0;
							if (strIndCnt != null)
							{
								iIndent = Integer.parseInt(strIndCnt);
							}
							// インデントを作成。
							StringBuffer sbIndent = new StringBuffer(10);
							for (int ix=0; ix<iIndent; ix++)
							{
								sbIndent.append("　");
							}
							// 料金項目名称を取得し、インデントを付加する
							simpleRePrcKmkNm1 = sbIndent.append(simpleRePrcKmkNm1).toString();
							
							childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM, simpleRePrcKmkNm1);
						}
						else
						{
							childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_KMK_NM));
						}
						
					}
					else
					{
					//ANK-4468-00-00 ADD END
						childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_KMK_NM));
					//ANK-4468-00-00 ADD START
					}
					//ANK-4468-00-00 ADD END
				}
				
// ANK-4475-00-00 ADD START
				// 通信サービス料金マップ.請求内訳一覧明細.表示順 ← 請求内訳一覧明細.表示順
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.DSP_JUN)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_DSP_JUN, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_DSP_JUN, childTemplate.getString(ECH0101B010CBSMsg1List.DSP_JUN));
				}
// ANK-4475-00-00 ADD END
				
				// 通信サービス料金マップ.請求内訳一覧明細.請求書NO欄表示制御フラグ ← 請求内訳一覧明細.請求書ＮＯ欄表示制御フラグ
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.SKS_NO_RAN_DSP_CTRL_FLG))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SKS_NO_RAN_DSP_CTRL_FLG, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SKS_NO_RAN_DSP_CTRL_FLG, childTemplate.getString(ECH0101B010CBSMsg1List.SKS_NO_RAN_DSP_CTRL_FLG));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.サービス契約番号表示制御フラグ ← 請求内訳一覧明細.サービス契約番号表示制御フラグ
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.SVKEI_NO_DSP_CTRL_FLG)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SVKEI_NO_DSP_CTRL_FLG, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SVKEI_NO_DSP_CTRL_FLG, childTemplate.getString(ECH0101B010CBSMsg1List.SVKEI_NO_DSP_CTRL_FLG));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.利用期間表示制御フラグ ← 請求内訳一覧明細.利用期間表示制御フラグ
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.USE_PRD_DSP_CTRL_FLG))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_USE_PRD_DSP_CTRL_FLG, new String());
				} 
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_USE_PRD_DSP_CTRL_FLG, childTemplate.getString(ECH0101B010CBSMsg1List.USE_PRD_DSP_CTRL_FLG));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.金額表示カラム数 ← 請求内訳一覧明細.金額表示カラム数
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.AMNT_DSP_COLUM_CNT)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT, new String());
				} 
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT, childTemplate.getString(ECH0101B010CBSMsg1List.AMNT_DSP_COLUM_CNT));
				}

				// 通信サービス料金マップ.請求内訳一覧明細.ご利用期間 ← 請求内訳一覧明細.ご利用期間
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.USE_KIKAN)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_USE_KIKAN, new String());
				} 
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_USE_KIKAN, childTemplate.getString(ECH0101B010CBSMsg1List.USE_KIKAN));
				}

				// 通信サービス料金マップ.請求内訳一覧明細.税区分 ← 請求内訳一覧明細.税区分
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.TAX_DIV_DSP_FLG)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_TAX_DIV_DSP_FLG, new String());
				} 
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_TAX_DIV_DSP_FLG, childTemplate.getString(ECH0101B010CBSMsg1List.TAX_DIV_DSP_FLG));
				}

				// 通信サービス料金マップ.請求内訳一覧明細.金額編集パターンコード ← 請求内訳一覧明細.金額編集パターンコード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.AMNT_HENSHU_PTN_CD))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT_HENSHU_PTN_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT_HENSHU_PTN_CD, childTemplate.getString(ECH0101B010CBSMsg1List.AMNT_HENSHU_PTN_CD));
				}

				// 通信サービス料金マップ.請求内訳一覧明細.整理番号 ← 請求内訳一覧明細.整理番号
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.SEIRI_NO))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SEIRI_NO, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SEIRI_NO, childTemplate.getString(ECH0101B010CBSMsg1List.SEIRI_NO));
				}
				
				// 通信サービス料金マップ.請求内訳一覧明細.整理番号表示制御フラグ ← 請求内訳一覧明細.整理番号表示制御フラグ
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.SEIRI_NO_DSP_CTRL_FLG))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SEIRI_NO_DSP_CTRL_FLG, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_SEIRI_NO_DSP_CTRL_FLG, childTemplate.getString(ECH0101B010CBSMsg1List.SEIRI_NO_DSP_CTRL_FLG));
				}
				
				// 通信サービス料金マップ.請求内訳一覧明細.マンションＩＤ ← 請求内訳一覧明細.マンションＩＤ
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.MANSION_ID))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_MANSION_ID, new String());
				} 
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_MANSION_ID, childTemplate.getString(ECH0101B010CBSMsg1List.MANSION_ID));
				}
				
				// 通信サービス料金マップ.請求内訳一覧明細.マンションＩＤ表示制御フラグ ← 請求内訳一覧明細.マンションＩＤ表示制御フラグ
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.MANS_ID_DSP_CTRL_FLG))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_MANS_ID_DSP_CTRL_FLG, new String());
				} 
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_MANS_ID_DSP_CTRL_FLG, childTemplate.getString(ECH0101B010CBSMsg1List.MANS_ID_DSP_CTRL_FLG));
				}
				
				// 通信サービス料金マップ.請求内訳一覧明細.合算請求年月 ← 請求内訳一覧明細.合算請求年月
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.GSAN_SEIKY_YM))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_GSAN_SEIKY_YM, new String());
				} 
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_GSAN_SEIKY_YM, childTemplate.getString(ECH0101B010CBSMsg1List.GSAN_SEIKY_YM));
				}
//ANK-4543-00-00 ADD START
				// 通信サービス料金マップ.請求内訳一覧明細.NTT卸契約エラーフラグ ← 請求内訳一覧明細.NTT卸契約エラーフラグ
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.NTT_ERR_FLG)) {
					childMap.put("ntt_err_flg", new String());
				} else {
					childMap.put("ntt_err_flg", childTemplate.getString(ECH0101B010CBSMsg1List.NTT_ERR_FLG));
				}
//ANK-4543-00-00 ADD END

				// 出力用整理番号
				childMap.put(JCHTushinSvcConstCC.ECH0101B010_OUT_SEIRI_NO, new String());
				
				if(!childTemplate.isNull(ECH0101B010CBSMsg1List.SEIRI_NO_DSP_CTRL_FLG))
				{
					String seiriNoDspCtrlFlg = childTemplate.getString(ECH0101B010CBSMsg1List.SEIRI_NO_DSP_CTRL_FLG);
					String seiriNo = editSeriNo(childTemplate.getString(ECH0101B010CBSMsg1List.SEIRI_NO));
					String mansIdDspCtrlFlg = childTemplate.getString(ECH0101B010CBSMsg1List.MANS_ID_DSP_CTRL_FLG);
					String mansionId = childTemplate.getString(ECH0101B010CBSMsg1List.MANSION_ID);
					
					if(seiriNoDspCtrlFlg.equals(JACStrConst.SKS_NO_RAN_DSP_CTRL_FLG_ON))
					{
						if(!JCRUtilCommon.isNull(seiriNo))
						{
							childMap.put(JCHTushinSvcConstCC.ECH0101B010_OUT_SEIRI_NO, seiriNo);
// DELETE START 2013.11.18 ANK-1750-00-00
//							// 整理番号マップに整理番号をキーとしてput(重複は上書き)
//							seiriNoMap.put(seiriNo, null);
// DELETE END 2013.11.11 ANK-1750-00-00
						}
					}
					else if(mansIdDspCtrlFlg.equals(JACStrConst.MANS_ID_DSP_CTRL_FLG_ON))
					{
						if(!JCRUtilCommon.isNull(mansionId))
						{
							childMap.put(JCHTushinSvcConstCC.ECH0101B010_OUT_SEIRI_NO, mansionId);
// DELETE START 2013.11.18 ANK-1750-00-00
//							// 整理番号マップにマンションＩＤをキーとしてput(重複は上書き)
//							seiriNoMap.put(mansionId, null);
// DELETE END 2013.11.11 ANK-1750-00-00
						}
					}
				}
				
// ANK-4475-00-00 ADD START
				// 通信サービス料金マップ.請求内訳一覧明細.卸料金分類コード ← 請求内訳一覧明細.卸料金分類コード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.OROSI_PRC_BRI_CD))
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_OROSI_PRC_BRI_CD, new String());
				} 
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_OROSI_PRC_BRI_CD, childTemplate.getString(ECH0101B010CBSMsg1List.OROSI_PRC_BRI_CD));
				}
// ANK-4475-00-00 ADD END
			}
		}

// DELETE START 2013.11.18 ANK-1750-00-00
//		// 整理番号マップサイズ
//		int seiriNoMapSize = seiriNoMap.size();
// DELETE END 2013.11.11 ANK-1750-00-00

		// すでに出力済みの整理番号をキーとして保持するmap(重複は上書き)
		HashMap<String, String> outputSeriNoMap = new HashMap<String, String>();

		// 請求内訳情報.ＩＤ番号が設定された後、Noを設定しなおす
		for (int i = 0; i < uwSize; i++)
		{
			if (i >= dataList.size())
			{
				dataList.add(new HashMap());
			}
			HashMap<String, Object> childSeiriNoMap = (HashMap)dataList.get(i);

// DELETE START 2013.11.18 ANK-1750-00-00
//			// 整理番号が1種類の場合は整理番号の値を消去
//			if (seiriNoMapSize == 1)
//			{
//				childSeiriNoMap.put(JCHTushinSvcConstCC.ECH0101B010_OUT_SEIRI_NO, new String());
//			}
//			else
//			{
// DELETE END 2013.11.11 ANK-1750-00-00
			String outSeiriNo = (String)childSeiriNoMap.get(JCHTushinSvcConstCC.ECH0101B010_OUT_SEIRI_NO);

			if (!JCRUtilCommon.isNull(outSeiriNo))
			{
				// 合算請求年月を取得
				String gsanSeikyYm = (String)childSeiriNoMap.get(JCHTushinSvcConstCC.ECH0101B010_GSAN_SEIKY_YM);
				
				// マップキーを作成
				String sKey = outSeiriNo.concat(gsanSeikyYm);
				
				// 出力済みの「"整理番号"＋"合算請求年月"」と同一の場合は請求内訳情報の整理番号を消去する
				if (outputSeriNoMap.containsKey(sKey))
				{
					childSeiriNoMap.put(JCHTushinSvcConstCC.ECH0101B010_OUT_SEIRI_NO, new String());
				}
				outputSeriNoMap.put(sKey, null);
			}
// DELETE START 2013.11.18 ANK-1750-00-00
//			}
// DELETE END 2013.11.11 ANK-1750-00-00
		}

		//ANK-4468-00-00 ADD START
		if(flg.equals("1"))
		{
			//請求内訳データ明細行データリスト
			dataMap.put("ECH0101B010CBSMsg1List_2", dataList);
		}
		else
		{
		//ANK-4468-00-00 ADD END
			dataMap.put("ECH0101B010CBSMsg1List", dataList);
		//ANK-4468-00-00 ADD START
		}
		//ANK-4468-00-00 ADD END

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		// 請求内訳にデータが存在しない場合、サービスIFの関連チェックエラーを返す。
		if (uwSize == 0)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = "1100";
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
			ArrayList<Object> errorInfoArray = new ArrayList<Object>();
			HashMap<String, Object> itemCheckErrors = new HashMap<String, Object>();
			HashMap<String, Object> errorInfo = new HashMap<String, Object>();
			itemCheckErrors.put(ECH0101B010CBSMsg.ECH0101B010CBSMSG1LIST_ERR, "EA");
			errorInfo.put("ITEM_CHECK_ERRORS", itemCheckErrors);
			errorInfo.put("RETURN_CODE", "0");
			errorInfo.put("TEMPLATE_ID", "ECH0101B010");
			errorInfo.put("STATUS", formatStatus);
			errorInfoArray.add(errorInfo);
			param.setControlMapData(SCControlMapKeys.ERROR_INFO, errorInfoArray);
			dataMap.put(ECH0101B010CBSMsg.ECH0101B010CBSMSG1LIST_ERR, "EA");
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(formatStatus));
			throw scCallEx;
		}

		return param;
	}

	// ANK-3838-00-00 ADD START
	/**
	 * パーフェクト口座一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0941A010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}
		
		ArrayList dataList = null;
		
		if (parentTemplate != null)
		{
			templateArray = parentTemplate.getCAANMsgList(ECH0941A010CBSMsg.ECH0941A010CBSMSG1LIST);
		}
		
		dataList = (ArrayList)dataMap.get("ECH0941A010CBSMsg1List");

		if (dataList == null)
		{
			dataList = new ArrayList();
		}
		
		if (templateArray != null)
		{
			int uwSize = templateArray.length;
			
			for (int i = 0; i < uwSize; i++) 
			{
				CAANMsg childTemplate = templateArray[i];
				if (i >= dataList.size()) 
				{
					dataList.add(new HashMap());
				}
				
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);
				
				// 通信サービス料金マップ.パーフェクト口座一意照会明細.請求契約番号 ← パーフェクト口座一意照会明細.請求契約番号
				if (childTemplate.isNull(ECH0941A010CBSMsg1List.SEIKY_KEI_NO)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_SEIKY_KEI_NO, new String());
				}
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_SEIKY_KEI_NO, childTemplate.getString(ECH0941A010CBSMsg1List.SEIKY_KEI_NO));
				}
				
				// 通信サービス料金マップ.パーフェクト口座一意照会明細.パーフェクト口座番号 ← パーフェクト口座一意照会明細.パーフェクト口座番号
				if (childTemplate.isNull(ECH0941A010CBSMsg1List.PKOZA_NO)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_PKOZA_NO, new String());
				}
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_PKOZA_NO, childTemplate.getString(ECH0941A010CBSMsg1List.PKOZA_NO));
				}
				
				// 通信サービス料金マップ.パーフェクト口座一意照会明細.パーフェクト口座利用有無 ← パーフェクト口座一意照会明細.パーフェクト口座利用有無
				if (childTemplate.isNull(ECH0941A010CBSMsg1List.PKOZA_USE_UM)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_PKOZA_USE_UM, new String());
				}
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_PKOZA_USE_UM, childTemplate.getString(ECH0941A010CBSMsg1List.PKOZA_USE_UM));
				}
				
				// 通信サービス料金マップ.パーフェクト口座一意照会明細.パーフェクト口座金融機関名 ← パーフェクト口座一意照会明細.パーフェクト口座金融機関名
				if (childTemplate.isNull(ECH0941A010CBSMsg1List.PKOZA_BANK_NM)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_PKOZA_BANK_NM, new String());
				}
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_PKOZA_BANK_NM, childTemplate.getString(ECH0941A010CBSMsg1List.PKOZA_BANK_NM));
				}
				
				// 通信サービス料金マップ.パーフェクト口座一意照会明細.パーフェクト口座支店名 ← パーフェクト口座一意照会明細.パーフェクト口座支店名
				if (childTemplate.isNull(ECH0941A010CBSMsg1List.PKOZA_SHITEN_NM)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_PKOZA_SHITEN_NM, new String());
				}
				else
				{
					childMap.put(JCHTushinSvcConstCC.ECH0941A010_PKOZA_SHITEN_NM, childTemplate.getString(ECH0941A010CBSMsg1List.PKOZA_SHITEN_NM));
				}
			}
		}
		
		dataMap.put("ECH0941A010CBSMsg1List", dataList);
		
		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}
		
		return param;
	}
	// ANK-3838-00-00 ADD END

	/**
	 * 料金スケジュール定義一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param flg
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0501B020(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String flg) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0501B020CBSMsg.ECH0501B020CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				if(flg.equals(TOGT_FLG))
				{
					// 通信サービス料金マップ.イベント年月日 ← 料金スケジュール一意明細.イベント年月日
					if (childTemplate.isNull(ECH0501B020CBSMsg1List.EVENT_YMD))
					{
						dataMap.put(JCHTushinSvcConstCC.ECH0501B020_EVENT_YMD, new String());
					}
					else
					{
						dataMap.put(JCHTushinSvcConstCC.ECH0501B020_EVENT_YMD, childTemplate.getString(ECH0501B020CBSMsg1List.EVENT_YMD));
					}
				}
				else
				{
					// 通信サービス料金マップ.前月イベント年月日 ← 料金スケジュール一意明細.イベント年月日
					if (childTemplate.isNull(ECH0501B020CBSMsg1List.EVENT_YMD))
					{
						dataMap.put(JCHTushinSvcConstCC.ECH0501B020_ZEN_EVENT_YMD, new String());
					} 
					else 
					{
						dataMap.put(JCHTushinSvcConstCC.ECH0501B020_ZEN_EVENT_YMD, childTemplate.getString(ECH0501B020CBSMsg1List.EVENT_YMD));
					}
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * 請求一覧照会（請求書料金情報）サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0051B040(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0051B040CBSMsg.ECH0051B040CBSMSG1LIST);

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 通信サービス料金マップ.金融機関名 ← 請求一覧明細.金融機関名
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.BANK_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_BANK_NM, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_BANK_NM, childTemplate.getString(ECH0051B040CBSMsg1List.BANK_NM));
				}
				// 通信サービス料金マップ.金融機関支店名 ← 請求一覧明細.金融機関支店名
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.BANK_SHITEN_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_BANK_SHITEN_NM, new String());
				} 
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_BANK_SHITEN_NM, childTemplate.getString(ECH0051B040CBSMsg1List.BANK_SHITEN_NM));
				}
				// 通信サービス料金マップ.預金種目コード名称 ← 請求一覧明細.預金種目コード名称
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.YOKIN_SHUMOKU_NM))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_YOKIN_SHUMOKU_NM, new String());
				} 
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_YOKIN_SHUMOKU_NM, childTemplate.getString(ECH0051B040CBSMsg1List.YOKIN_SHUMOKU_NM));
				}
				// 通信サービス料金マップ.口座番号 ← 請求一覧明細.口座番号
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.KOZA_NO)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_KOZA_NO, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_KOZA_NO, childTemplate.getString(ECH0051B040CBSMsg1List.KOZA_NO));
				}
				// OM-2021-0000584 ADD START
				// 通信サービス料金マップ.金融機関コード ← 請求一覧明細.金融機関コード
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.BANK_CD)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_BANK_CD, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_BANK_CD, childTemplate.getString(ECH0051B040CBSMsg1List.BANK_CD));
				}
				// 通信サービス料金マップ.通帳番号← 請求一覧明細.通帳番号
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.TSUCHO_NO)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_TSUCHO_NO, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_TSUCHO_NO, childTemplate.getString(ECH0051B040CBSMsg1List.TSUCHO_NO));
				}
				// OM-2021-0000584 ADD END
				// 通信サービス料金マップ.領収金額 ← 請求一覧明細.（請求金額）
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.AMNT1)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_RECEIPT, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_RECEIPT, childTemplate.getString(ECH0051B040CBSMsg1List.AMNT1));
				}
				// 通信サービス料金マップ.うち消費税 ← 請求一覧明細.（請求税額）
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.AMNT2)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_TAX, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_TAX, childTemplate.getString(ECH0051B040CBSMsg1List.AMNT2));
				}
				// 通信サービス料金マップ.前月請求年月 ← 請求一覧明細.請求年月
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.SEIKY_YM))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_ZEN_SEIKY_YM, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_ZEN_SEIKY_YM, childTemplate.getString(ECH0051B040CBSMsg1List.SEIKY_YM));
				}
				// 通信サービス料金マップ.領収額出力有無 ← 請求一覧明細.領収額出力有無
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.RECEIPT_AMNT_OUTPUT_UM))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_RECEIPT_AMNT_OUTPUT_UM, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_RECEIPT_AMNT_OUTPUT_UM, childTemplate.getString(ECH0051B040CBSMsg1List.RECEIPT_AMNT_OUTPUT_UM));
				}
				// 通信サービス料金マップ.合算請求フラグ ← 請求一覧明細.合算請求フラグ
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.GSAN_SEIKY_FLG))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_GSAN_SEIKY_FLG, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_GSAN_SEIKY_FLG, childTemplate.getString(ECH0051B040CBSMsg1List.GSAN_SEIKY_FLG));
				}
				// 通信サービス料金マップ.前受金充当額存在フラグ ← 請求一覧明細.前受金充当額存在フラグ
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.MAEUKE_JUTO_FLG))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_MAEUKE_JUTO_FLG, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_MAEUKE_JUTO_FLG, childTemplate.getString(ECH0051B040CBSMsg1List.MAEUKE_JUTO_FLG));
				}
// ANK-4415-00-00 ADD START
				// 通信サービス料金マップ.前月請求番号 ← 請求一覧明細.請求番号
				if (childTemplate.isNull(ECH0051B040CBSMsg1List.SEIKY_NO))
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_ZEN_SEIKY_NO, new String());
				}
				else
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0051B040_ZEN_SEIKY_NO, childTemplate.getString(ECH0051B040CBSMsg1List.SEIKY_NO));
				}
// ANK-4415-00-00 ADD END
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * 下りマッピング（業務パラメータ管理一意照会）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0321A010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEZM0321A010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		for (int i = 0; i < COL_EZM0321A010LISTS.length; i++)
		{
			ArrayList resultList = new ArrayList();
			dataMap.put(COL_EZM0321A010LISTS[i], resultList);
			CAANMsg[] msg1List = templates[i].getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		
			if (msg1List != null)
			{
				// 業務パラメータ管理一意明細件数分繰り返す
				for (CAANMsg msg : msg1List)
				{
					HashMap resultMap = new HashMap();
					resultList.add(resultMap);
			
					// 業務パラメータＩＤ ← 業務パラメータ管理一意明細.業務パラメータＩＤ
					resultMap.put(EZM0321A010CBSMsg1List.WORK_PARAM_ID, msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_ID));

					// 業務パラメータ設定値 ← 業務パラメータ管理一意明細.業務パラメータ設定値
					resultMap.put(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE, msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE));
				}
			}
		}
		
		return retParam;
	}

	//ANK-4418-00-00 ADD START
	/**
	 * 下りマッピング（業務パラメータ管理一意照会）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0321A010_2(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEZM0321A010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		for (int i = 0; i < COL_EZM0321A010LISTM.length; i++)
		{
			ArrayList resultList = new ArrayList();
			dataMap.put(COL_EZM0321A010LISTM[i], resultList);
			CAANMsg[] msg1List = templates[i].getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		
			if (msg1List != null)
			{
				// 業務パラメータ管理一意明細件数分繰り返す
				for (CAANMsg msg : msg1List)
				{
					HashMap resultMap = new HashMap();
					resultList.add(resultMap);
			
					// 業務パラメータＩＤ ← 業務パラメータ管理一意明細.業務パラメータＩＤ
					resultMap.put(EZM0321A010CBSMsg1List.WORK_PARAM_ID, msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_ID));

					// 業務パラメータ設定値 ← 業務パラメータ管理一意明細.業務パラメータ設定値
					resultMap.put(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE, msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE));
				}
			}
		}
		
		return retParam;
	}
	//ANK-4418-00-00 ADD END
//ANK-4595-01-00 ADD START
	/**
	 * 下りマッピング（業務パラメータ管理一意照会）(電気単独)
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0321A010_3(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEZM0321A010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		for (int i = 0; i < COL_EZM0321A010LISTM.length; i++)
		{
			ArrayList resultList = new ArrayList();
			dataMap.put(COL_EZM0321A010LISTM[i], resultList);
			CAANMsg[] msg1List = templates[i].getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		
			if (msg1List != null)
			{
				// 業務パラメータ管理一意明細件数分繰り返す
				for (CAANMsg msg : msg1List)
				{
					HashMap resultMap = new HashMap();
					resultList.add(resultMap);
			
					// 業務パラメータＩＤ ← 業務パラメータ管理一意明細.業務パラメータＩＤ
					resultMap.put(EZM0321A010CBSMsg1List.WORK_PARAM_ID, msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_ID));

					// 業務パラメータ設定値 ← 業務パラメータ管理一意明細.業務パラメータ設定値
					resultMap.put(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE, msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE));
				}
			}
		}
		
		return retParam;
	}
//ANK-4595-01-00 ADD END

	/**
	 * 下りマッピング（料金項目抽出変換一覧照会）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @param dataMap 
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0401B010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoECH0401B010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}

		for (int i = 0; i < COL_ECH0401B010LISTS.length; i++)
		{
			ArrayList resultList = new ArrayList();
			dataMap.put(COL_ECH0401B010LISTS[i], resultList);
			CAANMsg[] msg1List = templates[i].getCAANMsgList(ECH0401B010CBSMsg.ECH0401B010CBSMSG1LIST);
		
			if (msg1List != null)
			{
				// 料金項目抽出変換一覧明細件数分繰り返す
				for (CAANMsg msg : msg1List)
				{
					HashMap<String, String> resultMap = new HashMap<String, String>();
					resultList.add(resultMap);

					// 料金グループコード ← 料金抽出変換一覧明細.料金グループコード
					String prcGrpCd = msg.getString(ECH0401B010CBSMsg1List.PRC_GRP_CD);
					resultMap.put(ECH0401B010CBSMsg1List.PRC_GRP_CD, prcGrpCd);

					// 料金コースコード ← 料金抽出変換一覧明細.料金コースコード
					String pcrsCd = msg.getString(ECH0401B010CBSMsg1List.PCRS_CD);
					resultMap.put(ECH0401B010CBSMsg1List.PCRS_CD, pcrsCd);

					// 料金サービスコード ← 料金抽出変換一覧明細.料金サービスコード
					String prcSvcCd = msg.getString(ECH0401B010CBSMsg1List.PRC_SVC_CD);
					resultMap.put(ECH0401B010CBSMsg1List.PRC_SVC_CD, prcSvcCd);

					// 料金項目コード ← 料金抽出変換一覧明細.料金項目コード
					String prcKmkCd = msg.getString(ECH0401B010CBSMsg1List.PRC_KMK_CD);
					resultMap.put(ECH0401B010CBSMsg1List.PRC_KMK_CD, prcKmkCd);
				}
			}
		}

		return retParam;
	}

	// ANK-4401-00-00 ADD START
	/**
	 * システムパラメータ管理一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0311A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(EZM0311A010CBSMsg.EZM0311A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 通信サービス料金マップ.システムパラメータ管理一意照会明細.システムパラメータ設定値1 ← システムパラメータ管理一意照会明細.システムパラメータ設定値1
				if (childTemplate.isNull(EZM0311A010CBSMsg1List.SYS_PARAM_SETTE_VALUE_1)) 
				{
					dataMap.put(JCHTushinSvcConstCC.EZM0311A010_SYS_PARAM_SETTE_VALUE_1, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.EZM0311A010_SYS_PARAM_SETTE_VALUE_1, childTemplate.getString(EZM0311A010CBSMsg1List.SYS_PARAM_SETTE_VALUE_1));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}
	// ANK-4401-00-00 ADD END
	// ANK-4415-00-00 ADD START
	/**
	 * 入金一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0111B010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0111B010CBSMsg.ECH0111B010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 通信サービス料金マップ.入金一覧照会明細.領収年月日 ← 入金一覧照会明細.領収年月日
				if (childTemplate.isNull(ECH0111B010CBSMsg1List.PAY_YMD)) 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0111B010_PAY_YMD, new String());
				}
				else 
				{
					dataMap.put(JCHTushinSvcConstCC.ECH0111B010_PAY_YMD, childTemplate.getString(ECH0111B010CBSMsg1List.PAY_YMD));
				}
			}
		}
		else
		{
			dataMap.put(JCHTushinSvcConstCC.ECH0111B010_PAY_YMD, new String());
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}
	// ANK-4415-00-00 ADD END

// ANK-4475-00-00 ADD START
	/**
	 * 料金項目出力名称サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0391A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0391A010CBSMsg.ECH0391A010CBSMSG1LIST);

		if (templateArray != null) {
			for (int i = 0; i < templateArray.length; i++) {
				CAANMsg childTemplate = templateArray[i];

				// 通信サービス料金マップ. 料金項目出力名称一意照会明細.料金グループコード ← 料金項目出力名称一意照会明細.料金グループコード
				if (childTemplate.isNull(ECH0391A010CBSMsg1List.PRC_GRP_CD)) {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PRC_GRP_CD, new String());
				} else {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PRC_GRP_CD, childTemplate.getString(ECH0391A010CBSMsg1List.PRC_GRP_CD));
				}

				// 通信サービス料金マップ.料金項目出力名称一意照会明細.料金コースコード ← 料金項目出力名称一意照会明細.料金コースコード
				if (childTemplate.isNull(ECH0391A010CBSMsg1List.PCRS_CD)) {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PCRS_CD, new String());
				} else {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PCRS_CD, childTemplate.getString(ECH0391A010CBSMsg1List.PCRS_CD));
				}

				// 通信サービス料金マップ.料金項目出力名称一意照会明細.料金サービスコード ← 料金項目出力名称一意照会明細.料金サービスコード
				if (childTemplate.isNull(ECH0391A010CBSMsg1List.PRC_SVC_CD)) {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PRC_SVC_CD, new String());
				} else {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PRC_SVC_CD, childTemplate.getString(ECH0391A010CBSMsg1List.PRC_SVC_CD));
				}

				// 通信サービス料金マップ.料金項目出力名称一意照会明細.料金項目コード ← 料金項目出力名称一意照会明細.料金項目コード
				if (childTemplate.isNull(ECH0391A010CBSMsg1List.PRC_KMK_CD)) {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_CD, new String());
				} else {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_CD, childTemplate.getString(ECH0391A010CBSMsg1List.PRC_KMK_CD));
				}

				// 通信サービス料金マップ.料金項目出力名称一意照会明細.料金項目名称 ← 料金項目出力名称一意照会明細.料金項目名称
				if (childTemplate.isNull(ECH0391A010CBSMsg1List.PRC_KMK_NM)) {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_NM, new String());
				} else {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_NM, childTemplate.getString(ECH0391A010CBSMsg1List.PRC_KMK_NM));
				}
				
				// 通信サービス料金マップ.料金項目出力名称一意照会明細.表示順 ← 料金項目出力名称一意照会明細.表示順
				if (childTemplate.isNull(ECH0391A010CBSMsg1List.DSP_JUN)) {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_DSP_JUN, new String());
				} else {
					dataMap.put(JCHTushinSvcConstCC.ECH0391A010_DSP_JUN, childTemplate.getString(ECH0391A010CBSMsg1List.DSP_JUN));
				}

			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}
// ANK-4475-00-00 ADD END

	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, 
									CAANMsg[] templates, int returnCode) throws RequestParameterException
	{

		for (CAANMsg template : templates)
		{
			String templateId = template.getString("templateID");
			CAANMsg[] workTemplates = { template };
			if (TEMPLATE_ID_EKK0491A010.equals(templateId))
			{
				// 請求契約一意照会
				editErrorInfoEKK0491A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0051A010.equals(templateId))
			{
				// 請求一意照会
				editErrorInfoECH0051A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0101B010.equals(templateId))
			{
				// 請求内訳一覧照会
				editErrorInfoECH0101B010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0501B020.equals(templateId))
			{
				// 料金スケジュール定義一覧照会
				editErrorInfoECH0501B020(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0051B040.equals(templateId))
			{
				// 請求一覧照会（請求書料金情報）
				editErrorInfoECH0051B040(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECC0041A110.equals(templateId))
			{
				// 帳票生成
				editErrorInfoECC0041A110(param, workTemplates, returnCode);
			}
			// ANK-3838-00-00 ADD START
			else if (TEMPLATE_ID_ECH0941A010.equals(templateId))
			{
				// 帳票生成
				editErrorInfoECH0941A010(param, workTemplates, returnCode);
			}
			// ANK-3838-00-00 ADD END
			// ANK-4401-00-00 ADD START
			else if (TEMPLATE_ID_EZM0311A010.equals(templateId))
			{
				// システムパラメータ管理一意照会
				editErrorInfoEZM0311A010(param, workTemplates, returnCode);
			}
			// ANK-4401-00-00 ADD END
// ANK-4475-00-00 ADD START
			else if (TEMPLATE_ID_ECH0391A010.equals(templateId))
			{
				// 料金項目出力名称一意照会
				editErrorInfo_ECH0391A010(param, workTemplates, returnCode);
			}
// ANK-4475-00-00 ADD END
		}

		return param;
	}

	/**
	 * 請求契約一意照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEKK0491A010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0491A010CBSMsg.STATUS);

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 請求契約一意照会マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		// 請求契約一意照会マップ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR, template.getString(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}

		return param;
	}

	/**
	 * 請求一意照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECH0051A010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0051A010CBSMsg.STATUS);

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 請求一意照会マップ.ＫＥＹ＿請求番号 → ＫＥＹ＿請求番号 のエラー情報返却
		if (!template.isNull(ECH0051A010CBSMsg.KEY_SEIKY_NO_ERR)) 
		{
			if (!inMap.containsKey(ECH0051A010CBSMsg.KEY_SEIKY_NO_ERR))
			{
				inMap.put(ECH0051A010CBSMsg.KEY_SEIKY_NO_ERR, template.getString(ECH0051A010CBSMsg.KEY_SEIKY_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * 請求内訳一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECH0101B010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0101B010CBSMsg.STATUS);

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 請求内訳一覧照会マップ.ＫＥＹ＿請求番号 → ＫＥＹ＿請求番号 のエラー情報返却
		if (!template.isNull(ECH0101B010CBSMsg.KEY_SEIKY_NO_ERR)) 
		{
			if (!inMap.containsKey(ECH0101B010CBSMsg.KEY_SEIKY_NO_ERR)) 
			{
				inMap.put(ECH0101B010CBSMsg.KEY_SEIKY_NO_ERR, template.getString(ECH0101B010CBSMsg.KEY_SEIKY_NO_ERR));
			}
		}
		// 請求内訳一覧照会マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0101B010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0101B010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0101B010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(ECH0101B010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		// 請求内訳一覧照会マップ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(ECH0101B010CBSMsg.KEY_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey(ECH0101B010CBSMsg.KEY_SVC_KEI_NO_ERR)) 
			{
				inMap.put(ECH0101B010CBSMsg.KEY_SVC_KEI_NO_ERR, template.getString(ECH0101B010CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		// 請求内訳一覧照会マップ.ＫＥＹ＿システムコード → ＫＥＹ＿システムコード のエラー情報返却
		if (!template.isNull(ECH0101B010CBSMsg.KEY_SYS_CD_ERR))
		{
			if (!inMap.containsKey(ECH0101B010CBSMsg.KEY_SYS_CD_ERR))
			{
				inMap.put(ECH0101B010CBSMsg.KEY_SYS_CD_ERR, template.getString(ECH0101B010CBSMsg.KEY_SYS_CD_ERR));
			}
		}
		// 請求内訳一覧照会マップ.ＫＥＹ＿業務機能識別コード → ＫＥＹ＿業務機能識別コード のエラー情報返却
		if (!template.isNull(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD_ERR))
			{
				inMap.put(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD_ERR, template.getString(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD_ERR));
			}
		}
		// 請求内訳一覧照会マップ.ＫＥＹ＿業務機能識別コード＿料金訂正可否 → ＫＥＹ＿業務機能識別コード＿料金訂正可否 のエラー情報返却
		if (!template.isNull(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD_PRC_TEISE_ERR))
		{
			if (!inMap.containsKey(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD_PRC_TEISE_ERR))
			{
				inMap.put(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD_PRC_TEISE_ERR, template.getString(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD_PRC_TEISE_ERR));
			}
		}
		// 請求内訳一覧照会マップ.ＫＥＹ＿料金項目名称種別コード → ＫＥＹ＿料金項目名称種別コード のエラー情報返却
		if (!template.isNull(ECH0101B010CBSMsg.KEY_PRC_KMK_NM_SBT_CD_ERR)) 
		{
			if (!inMap.containsKey(ECH0101B010CBSMsg.KEY_PRC_KMK_NM_SBT_CD_ERR))
			{
				inMap.put(ECH0101B010CBSMsg.KEY_PRC_KMK_NM_SBT_CD_ERR, template.getString(ECH0101B010CBSMsg.KEY_PRC_KMK_NM_SBT_CD_ERR));
			}
		}

		return param;
	}

	/**
	 * 料金スケジュール定義一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECH0501B020(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0501B020CBSMsg.STATUS);

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 料金スケジュール定義一覧照会マップ.ＫＥＹ＿イベントコード → ＫＥＹ＿イベントコード のエラー情報返却
		if (!template.isNull(ECH0501B020CBSMsg.KEY_EVENT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0501B020CBSMsg.KEY_EVENT_CD_ERR))
			{
				inMap.put(ECH0501B020CBSMsg.KEY_EVENT_CD_ERR, template.getString(ECH0501B020CBSMsg.KEY_EVENT_CD_ERR));
			}
		}
		// 料金スケジュール定義一覧照会マップ.ＫＥＹ＿イベント年月日 → ＫＥＹ＿イベント年月日 のエラー情報返却
		if (!template.isNull(ECH0501B020CBSMsg.KEY_SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(ECH0501B020CBSMsg.KEY_SEIKY_YM_ERR))
			{
				inMap.put(ECH0501B020CBSMsg.KEY_SEIKY_YM_ERR, template.getString(ECH0501B020CBSMsg.KEY_SEIKY_YM_ERR));
			}
		}
		return param;
	}


	/**
	 * 請求一覧照会（請求書料金情報）サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECH0051B040(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0101B010CBSMsg.STATUS);

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 請求一覧照会（請求書料金情報）マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0051B040CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0051B040CBSMsg.KEY_SEIKY_KEI_NO_ERR)) 
			{
				inMap.put(ECH0051B040CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(ECH0051B040CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		// 請求一覧照会（請求書料金情報）マップ.ＫＥＹ＿請求年月エラー → ＫＥＹ＿請求年月エラー
		if (!template.isNull(ECH0051B040CBSMsg.KEY_SEIKY_YM_ERR))
		{
			if (!inMap.containsKey(ECH0051B040CBSMsg.KEY_SEIKY_YM_ERR))
			{
				inMap.put(ECH0051B040CBSMsg.KEY_SEIKY_YM_ERR, template.getString(ECH0051B040CBSMsg.KEY_SEIKY_YM_ERR));
			}
		}
		// 請求一覧照会（請求書料金情報）マップ.ＫＥＹ＿請求種別コードエラー → ＫＥＹ＿請求種別コードエラー
		if (!template.isNull(ECH0051B040CBSMsg.KEY_SEIKY_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0051B040CBSMsg.KEY_SEIKY_SBT_CD_ERR))
			{
				inMap.put(ECH0051B040CBSMsg.KEY_SEIKY_SBT_CD_ERR, template.getString(ECH0051B040CBSMsg.KEY_SEIKY_SBT_CD_ERR));
			}
		}
		// 請求一覧照会（請求書料金情報）マップ.ＫＥＹ＿運用日付エラー →ＫＥＹ＿運用日付エラー
		if (!template.isNull(ECH0051B040CBSMsg.KEY_UNYO_YMD_ERR))
		{
			if (!inMap.containsKey(ECH0051B040CBSMsg.KEY_UNYO_YMD_ERR))
			{
				inMap.put(ECH0051B040CBSMsg.KEY_UNYO_YMD_ERR, template.getString(ECH0051B040CBSMsg.KEY_UNYO_YMD_ERR));
			}
		}
		// 請求一覧照会（請求書料金情報）マップ.ＫＥＹ＿業務パラメータＩＤ１エラー → ＫＥＹ＿業務パラメータＩＤ１エラー
		if (!template.isNull(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID1_ERR))
		{
			if (!inMap.containsKey(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID1_ERR))
			{
				inMap.put(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID1_ERR, template.getString(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID1_ERR));
			}
		}
		// 請求一覧照会（請求書料金情報）マップ.ＫＥＹ＿業務パラメータＩＤ２エラー → ＫＥＹ＿業務パラメータＩＤ２エラー
		if (!template.isNull(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID2_ERR))
		{
			if (!inMap.containsKey(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID2_ERR))
			{
				inMap.put(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID2_ERR, template.getString(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID2_ERR));
			}
		}
		// 請求一覧照会（請求書料金情報）マップ.ＫＥＹ＿業務パラメータＩＤ３エラー → ＫＥＹ＿業務パラメータＩＤ３エラー
		if (!template.isNull(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID3_ERR))
		{
			if (!inMap.containsKey(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID3_ERR))
			{
				inMap.put(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID3_ERR, template.getString(ECH0051B040CBSMsg.KEY_WORK_PARAM_ID3_ERR));
			}
		}
		return param;
	}

	/**
	 * 帳票生成サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECC0041A110(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECC0041A110CBSMsg.STATUS);
		if (returnCode != 0) 
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) 
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus) 
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		HashMap<String, Object> inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 帳票生成.帳票定義体の電子ファイル管理番号→ 帳票定義体の電子ファイル管理番号 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR, template.getString(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR));
			}
		}
		// 帳票生成.データファイルの電子ファイル管理番号→ データファイルの電子ファイル管理番号 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.DATA_FILE_NO_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.DATA_FILE_NO_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.DATA_FILE_NO_ERR, template.getString(ECC0041A110CBSMsg.DATA_FILE_NO_ERR));
			}
		}
		// 帳票生成.データファイル→ データファイル のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.DATA_FILE_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.DATA_FILE_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.DATA_FILE_ERR, template.getString(ECC0041A110CBSMsg.DATA_FILE_ERR));
			}
		}
		// 帳票生成.ユーザーID→ ユーザーID のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.USER_ID_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.USER_ID_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.USER_ID_ERR, template.getString(ECC0041A110CBSMsg.USER_ID_ERR));
			}
		}
		// 帳票生成.処理種別→ 処理種別 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.TRAN_SBT_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.TRAN_SBT_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.TRAN_SBT_ERR, template.getString(ECC0041A110CBSMsg.TRAN_SBT_ERR));
			}
		}

		// 帳票生成.FAX送信先コード区分→ FAX送信先コード区分 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR, template.getString(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR));
			}
		}

		return param;
	}

	// ANK-3838-00-00 ADD START
	/**
	 * パーフェクト口座一意照会実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECH0941A010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];
		
		int templateStatus = template.getInt(ECH0941A010CBSMsg.STATUS);
		if (returnCode != 0) 
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) 
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}
		
		if (templateStatus > bpStatus) 
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap<String, Object> inMap = null;
		
		/* ユーザデータ情報 */
		inMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// パーフェクト口座一意照会マップ.請求契約番号エラー → 請求契約番号エラー情報返却
		if (!template.isNull(ECH0941A010CBSMsg.KEY_SEIKY_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey(ECH0941A010CBSMsg.KEY_SEIKY_KEI_NO_ERR)) 
			{
				inMap.put(ECH0941A010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(ECH0941A010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		
		return param;
	}
	// ANK-3838-00-00 ADD END

	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEZM0321A010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		for (int i = 0; i < templates.length; i++)
		{
		CAANMsg template = templates[i];

			int templateStatus = template.getInt(EZM0321A010CBSMsg.STATUS);
			if (returnCode != 0)
			{
				templateStatus = 9000;
			}

			if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
			{
				templateStatus = 0;
			}

			int bpStatus = 0;
			Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
			if (obj == null)
			{
				bpStatus = -1;
			}
			else
			{
				bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
			}

			if (templateStatus > bpStatus)
			{
				// BPにサービスコンポーネントのステータスを設定する。
				String formatStatus = String.format("%1$04d", templateStatus);
				String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
				param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
				param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
			}
		
			// イベントコードエラー → 業務パラメータ管理一意照会.業務パラメータＩＤエラー
			if (!template.isNull(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR))
			{
				if (!inMap.containsKey(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR))
				{
					inMap.put(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR, template.getString(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR));
				}
			}
		}
		
		return param;
	}

	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoECH0401B010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0401B010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// システムコードエラー → 料金項目抽出変換一覧照会.システムコードエラー
		if (!template.isNull(ECH0401B010CBSMsg.KEY_SYS_CD_ERR))
		{
			if (!inMap.containsKey(ECH0401B010CBSMsg.KEY_SYS_CD_ERR))
			{
				inMap.put(ECH0401B010CBSMsg.KEY_SYS_CD_ERR, template.getString(ECH0401B010CBSMsg.KEY_SYS_CD_ERR));
			}
		}
		
		// 業務機能識別コードエラー → 料金項目抽出変換一覧照会.業務機能識別コードエラー
		if (!template.isNull(ECH0401B010CBSMsg.KEY_WORK_KINO_SKBT_CD_ERR))
		{
			if (!inMap.containsKey(ECH0401B010CBSMsg.KEY_WORK_KINO_SKBT_CD_ERR))
			{
				inMap.put(ECH0401B010CBSMsg.KEY_WORK_KINO_SKBT_CD_ERR, template.getString(ECH0401B010CBSMsg.KEY_WORK_KINO_SKBT_CD_ERR));
			}
		}
		
		// 抽出変換コードエラー → 料金項目抽出変換一覧照会.抽出変換コードエラー
		if (!template.isNull(ECH0401B010CBSMsg.KEY_CHSHT_CHG_CD_ERR))
		{
			if (!inMap.containsKey(ECH0401B010CBSMsg.KEY_CHSHT_CHG_CD_ERR))
			{
				inMap.put(ECH0401B010CBSMsg.KEY_CHSHT_CHG_CD_ERR, template.getString(ECH0401B010CBSMsg.KEY_CHSHT_CHG_CD_ERR));
			}
		}
		
		// 料金グループコードエラー → 料金項目抽出変換一覧照会.料金グループコードエラー
		if (!template.isNull(ECH0401B010CBSMsg.KEY_PRC_GRP_CD_ERR))
		{
			if (!inMap.containsKey(ECH0401B010CBSMsg.KEY_PRC_GRP_CD_ERR))
			{
				inMap.put(ECH0401B010CBSMsg.KEY_PRC_GRP_CD_ERR, template.getString(ECH0401B010CBSMsg.KEY_PRC_GRP_CD_ERR));
			}
		}
		
		// 料金コースコードエラー → 料金項目抽出変換一覧照会.料金コースコードエラー
		if (!template.isNull(ECH0401B010CBSMsg.KEY_PCRS_CD_ERR))
		{
			if (!inMap.containsKey(ECH0401B010CBSMsg.KEY_PCRS_CD_ERR))
			{
				inMap.put(ECH0401B010CBSMsg.KEY_PCRS_CD_ERR, template.getString(ECH0401B010CBSMsg.KEY_PCRS_CD_ERR));
			}
		}
		
		return param;
	}

	// ANK-4401-00-00 ADD START
	/**
	 * システムパラメータ管理一意照会実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEZM0311A010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];
		
		int templateStatus = template.getInt(EZM0311A010CBSMsg.STATUS);
		if (returnCode != 0) 
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) 
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}
		
		if (templateStatus > bpStatus) 
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap<String, Object> inMap = null;
		
		/* ユーザデータ情報 */
		inMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// システムパラメータ管理一意照会.ＫＥＹ＿システムパラメータ分類コードエラー → ＫＥＹ＿システムパラメータ分類コードエラー情報返却
		if (!template.isNull(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD_ERR)) 
		{
			if (!inMap.containsKey(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD_ERR)) 
			{
				inMap.put(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD_ERR, template.getString(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD_ERR));
			}
		}
		// システムパラメータ管理一意照会.ＫＥＹ＿システムパラメータＩＤエラー号→ ＫＥＹ＿システムパラメータＩＤエラー のエラー情報返却
		if (!template.isNull(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID_ERR)) 
		{
			if (!inMap.containsKey(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID_ERR)) 
			{
				inMap.put(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID_ERR, template.getString(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID_ERR));
			}
		}
		return param;
	}
	// ANK-4401-00-00 ADD END
	
// ANK-4475-00-00 ADD START
	/**
	 * 料金項目出力名称一意照会サービスインターフェイスのエラー情報をマッピングする。
	 * 
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	public IRequestParameterReadWrite editErrorInfo_ECH0391A010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];
		
		int templateStatus = template.getInt(ECH0391A010CBSMsg.STATUS);
		if (returnCode != 0) 
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) 
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}
		
		if (templateStatus > bpStatus) 
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap<String, Object> inMap = null;
		
		/* ユーザデータ情報 */
		inMap = (HashMap<String, Object>)param.getData(MAP_ID);
	
		if (!template.isNull(ECH0391A010CBSMsg.KEY_PRC_GRP_CD_ERR))
		{
			if (!inMap.containsKey("key_prc_grp_cd_err"))
			{
				inMap.put("key_prc_grp_cd_err", template.getString(ECH0391A010CBSMsg.KEY_PRC_GRP_CD_ERR));
			}
		}

		if (!template.isNull(ECH0391A010CBSMsg.KEY_PCRS_CD_ERR))
		{
			if (!inMap.containsKey("key_pcrs_cd_err"))
			{
				inMap.put("key_pcrs_cd_err", template.getString(ECH0391A010CBSMsg.KEY_PCRS_CD_ERR));
			}
		}

		if (!template.isNull(ECH0391A010CBSMsg.KEY_PRC_SVC_CD_ERR))
		{
			if (!inMap.containsKey("key_prc_svc_cd_err"))
			{
				inMap.put("key_prc_svc_cd_err", template.getString(ECH0391A010CBSMsg.KEY_PRC_SVC_CD_ERR));
			}
		}

		if (!template.isNull(ECH0391A010CBSMsg.KEY_PRC_KMK_CD_ERR))
		{
			if (!inMap.containsKey("key_prc_kmk_cd_err"))
			{
				inMap.put("key_prc_kmk_cd_err", template.getString(ECH0391A010CBSMsg.KEY_PRC_KMK_CD_ERR));
			}
		}

		if (!template.isNull(ECH0391A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("key_gene_add_dtm_err"))
			{
				inMap.put("key_gene_add_dtm_err", template.getString(ECH0391A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}

		return param;
	}
// ANK-4475-00-00 ADD END

	// ▲▲ エラー情報マッピング処理 ▲▲

	// ▼▼ 判定処理 ▼▼

	/**
	 * 請求契約情報が存在するか判定します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @return isExist
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private boolean isExistSeikyKeiInfo(IRequestParameterReadWrite param) throws RequestParameterException
	{
		boolean isExist = false;

		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap.get(JCHTushinSvcConstCC.EKK0491A010_SEIKY_KEI_STAT) != null
				&& JACStrConst.KARA_MOJI.equals(dataMap.get(JCHTushinSvcConstCC.EKK0491A010_SEIKY_KEI_STAT)) == false)
		{
			isExist = true;
		}

		return isExist;
	}
	// ▲▲ 判定処理 ▲▲

	// ANK-3838-00-00 DEL START
//	/**
//	 * 通信サービス料金請求書情報をCSV形式のバイナリデータに変換する。
//	 * @param param
//	 * @param bothDispMap 内訳両出力マップ
//	 * @return byte[]
//	 * @throws Exception
//	 */
//	@SuppressWarnings("unchecked")
//	private byte[] makeCSVDataTushinSvcPrcSeiky(IRequestParameterReadWrite param, HashMap<String, String> bothDispMap) throws Exception
//	{
//		HashMap<String, Object> parentMapCC = null;
//		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
//
//		ArrayList childList = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List");
//		
//		// 業務パラメータ管理情報取得
//		HashMap<String, String> workParamMap = getWorkParamKnri(param);
//
//		StringBuffer sb = new StringBuffer();
//
//		// フォーマット編集
//		String zuijiFlg = (String)parentMapCC.get("zuijiFlg");
//		// 送付先郵便番号
//		String sohusPcd = JACStrConst.KARA_MOJI;
//		if(ZUIJI_FLG.equals(zuijiFlg))
//		{
//			ArrayList seikyKeiykList = (ArrayList)parentMapCC.get("seikyKeiykList");
//			HashMap<String, Object> seikyKeiykMap = (HashMap<String, Object>)seikyKeiykList.get(0);
//			sohusPcd = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD);
//		}
//		else
//		{
//			sohusPcd = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD);
//		}
//
//// 2014.06.04 OM-2014-0001921 add start
//		// 通常文字サイズ か 小さい文字サイズ かのフラグ
//		HashMap<String, String> editFlgMap = new HashMap<String, String>();
////2014.06.04 OM-2014-0001921 add end
//		
//		// 送付先
//// 2014.06.04 OM-2014-0001921 mod start
////		ArrayList<String> addressList = editSohusaki(parentMapCC);
//		ArrayList<String> addressList = editSohusaki(parentMapCC, editFlgMap);
//// 2014.06.04 OM-2014-0001921 mod end
//
//// 2014.06.04 OM-2014-0001921 add start
//		// 住所リストから更新用住所配列を取得
//		String[] strAddress1 = getAddressArray(addressList.get(0), editFlgMap);
//		String[] strAddress2 = getAddressArray(addressList.get(1), editFlgMap);
//		String[] strAddress3 = getAddressArray(addressList.get(2), editFlgMap);
//		String[] strAddress4 = getAddressArray(addressList.get(3), editFlgMap);
////2014.06.04 OM-2014-0001921 add end
//
//		// 送付先名・部課名・担当者名
//		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);
//
//		// カスタマバーコード
//		String customerBarCd = editOutputCustomerBarCd(parentMapCC);
//		
//		// 発行番号
//		String hakkoNum = editHakkoNo(parentMapCC);
//
//		// 発行日←オンライン運用日付
//		String hakkoYmd = JCCBPCommon.getOnlineOpeDate(null);
//		String hakkoYear = editYmd(hakkoYmd, DATE_KBN_YEAR);
//		String hakkoMonth = editYmd(hakkoYmd, DATE_KBN_MON);
//		String hakkoDay = editYmd(hakkoYmd, DATE_KBN_DAY);
//
//		// ご請求年月月
//		String seikyYm = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM)).trim();
//		String seikyYear = editYmd(seikyYm, DATE_KBN_YEAR);
//		String seikyMonth = editYmd(seikyYm, DATE_KBN_MON);
//
//		// 支払期限日
//		String payYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.PAY_KIGEN_YMD)).trim();
//		String payYear = editYmd(payYmd, DATE_KBN_YEAR);
//		String payMonth = editYmd(payYmd, DATE_KBN_MON);
//		String payDay = editYmd(payYmd, DATE_KBN_DAY);
//
//		// EAN取扱期限年月日
//		String eanYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.HANDING_KIGEN_YMD)).trim();
//		
//		String eanMonth = new String();
//		String eanDay = new String();
//		
//		// EAN取扱期限年月日が"20991231"の場合
//		if(CONTENT_YMD.equals(eanYmd))
//		{
//			// 月日共にハイフン(--)を設定する
//			eanMonth = HYPHEN;
//			eanDay = HYPHEN;
//		}
//		else
//		{
//			eanMonth = editZeroSpace(editYmd(eanYmd, DATE_KBN_MON));
//			eanDay = editZeroSpace((editYmd(eanYmd, DATE_KBN_DAY)));
//		}
//
//		String strweek = this.getDayOfWeek(payYmd);
//
//		// OCR番号をスキーマから取得
//		String ocrNo = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_OCR_NO);
//
//		String strOcr = JACStrConst.KARA_MOJI;
//		if(!(ocrNo == null || JACStrConst.KARA_MOJI.equals(ocrNo)))
//		{
//			// OCR番号
//			strOcr = ocrNo.substring(0, 32);
//		}
//
//		// お知らせ
//		ArrayList<String> infoList = editInformation(parentMapCC);
//
//		// 印紙税対象額を「発行日」を基準日として取得する
//		long inshiTaxTgAmnt = Long.valueOf(JCHStampDutyUtil.getTaxableAmount(JACStrConst.CALLER_SCREEN, null, hakkoYmd));
//		
//		// 収入印紙貼付欄マスク
//		String shInsHrtkMask  = JACStrConst.KARA_MOJI;
//		
//		long seikyAmnt = Long.parseLong((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT));
//		if(seikyAmnt < inshiTaxTgAmnt)
//		{
//			// 印紙税対象ではない
//			shInsHrtkMask = SN_INS_HRTK_MASK_AST;
//		}
//
//		// うち消費税を取得
//		String tax = getZeiAmnt(param, LIST_KBN_MADO);
//		
//		//OM-2014-0003652 ADD START
//		// EANバーコード
//		String eanBarcode = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_EAN_BARCODE);
//		
//		if(eanBarcode == null)
//		{
//			eanBarcode = JACStrConst.KARA_MOJI;
//		}
//		else
//		{
//			eanBarcode = eanBarcode.trim();
//		}
//		
//		if(JACStrConst.EAN_SKBTS_XX.equals(eanBarcode))
//		{
//			eanBarcode = JACStrConst.KARA_MOJI;
//		}
//		//OM-2014-0003652 ADD END
//
//		HashMap<String, Object> msg_next = null;
//		// 明細行形成
//		for(int i = 0; i < childList.size(); i++) 
//		{
//			HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);
//			msg_next = null;//初期化
//			
//			if(i + 1 < childList.size())
//			{
//				msg_next = (HashMap<String, Object>)childList.get(i + 1);
//			}
//
//			// 金額
//			String strAmnt = new String();
//			// 金額内訳
//			String strUwAmnt = new String();
//			// 金額表示カラム数
//			String amntDspColumCnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT);
//
//			// 料金グループコード
//			String prcGrpCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
//			// 料金コースコード
//			String pcrsCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
//			// 料金サービスコード
//			String prcSvcCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
//			// 料金項目コード
//			String prcKmkCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
//
//			// 請求内訳両出力判定キー
//			StringBuilder prcKmkKey = new StringBuilder();
//			prcKmkKey.append(prcGrpCd).append(pcrsCd).append(prcSvcCd).append(prcKmkCd);
//
//			//mineo単独の場合
//			boolean isMineoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MINEO_TANDOKU);
//
//			// 料金項目コードが業務機能識別コード(請求内訳両出力)に存在する場合、金額、金額内訳両方に出力する
//			if (bothDispMap.containsKey(prcKmkKey.toString()))
//			{
//				// 金額
//				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
//				// 金額内訳
//				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
//			}
//			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT))
//			{
//				// 金額
//				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
//				
//				if(msg_next == null || JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT.equals((String)msg_next.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT)))
//				{
//					// 金額内訳
//					strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
//				}
//				
//			}
//			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_ID_NO_SUM))
//			{
//				// 金額内訳
//				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
//			}
//			else
//			{
//				// 内訳額
//				strAmnt = new String();
//				// 金額内訳
//				strUwAmnt = new String();
//			}
//
//			sb.append(getStringToDblQuote(sohusPcd))			// 郵便番号
//// 2014.06.04 OM-2014-0001921 mod start
////			.append(CSV + getStringToDblQuote((String)addressList.get(0)))		// 送付住所1
////			.append(CSV + getStringToDblQuote((String)addressList.get(1)))		// 送付住所2
////			.append(CSV + getStringToDblQuote((String)addressList.get(2)))		// 送付住所3
////			.append(CSV + getStringToDblQuote((String)addressList.get(3)))		// 送付住所4
//			.append(CSV + getStringToDblQuote(strAddress1[0]))		// 送付住所1
//			.append(CSV + getStringToDblQuote(strAddress2[0]))		// 送付住所2
//			.append(CSV + getStringToDblQuote(strAddress3[0]))		// 送付住所3
//			.append(CSV + getStringToDblQuote(strAddress4[0]))		// 送付住所4
//// 2014.06.04 OM-2014-0001921 mod end
//			.append(CSV + getStringToDblQuote((String)sohusNmList.get(0)))		// 送付先名
//			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))		// 送付先部署名
//			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))		// 送付先担当者名
//
//			.append(CSV + getStringToDblQuote(customerBarCd))	// カスタマーバーコード
//			.append(CSV + getStringToDblQuote(hakkoNum))		// 発行番号
//			.append(CSV + getStringToDblQuote(""))				// 請求書印刷番号１
//			.append(CSV + getStringToDblQuote(""))				// 請求書印刷番号２
//
//			.append(CSV + getStringToDblQuote(hakkoYear))		// 発行年月日（年）
//			.append(CSV + getStringToDblQuote(hakkoMonth))		// 発行年月日（月）
//			.append(CSV + getStringToDblQuote(hakkoDay))		// 発行年月日（日）
//			.append(CSV + getStringToDblQuote(seikyYear))		// 請求月（年）
//			.append(CSV + getStringToDblQuote(seikyMonth))		// 請求月（月）
//			
//			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT)))		// 請求額
//			.append(CSV + getStringToDblQuote(tax))				// うち消費税
//			.append(CSV + getStringToDblQuote(payYear))			// 支払期限日（年）
//			.append(CSV + getStringToDblQuote(payMonth))		// 支払期限日（月）
//			.append(CSV + getStringToDblQuote(payDay))			// 支払期限日（日）
//			.append(CSV + getStringToDblQuote(strweek))			// 支払期限日（曜日）
//			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)))		// お客様番号
//
//			.append(CSV + getStringToDblQuote((String)infoList.get(0)))				// お知らせ１
//			.append(CSV + getStringToDblQuote((String)infoList.get(1)))				// お知らせ２
//			.append(CSV + getStringToDblQuote((String)infoList.get(2)))				// お知らせ３
//			.append(CSV + getStringToDblQuote((String)infoList.get(3)))				// お知らせ４
//			.append(CSV + getStringToDblQuote((String)infoList.get(4)))				// お知らせ５
//			.append(CSV + getStringToDblQuote((String)infoList.get(5)))				// お知らせ６
//			.append(CSV + getStringToDblQuote((String)infoList.get(6)))				// お知らせ７
//			.append(CSV + getStringToDblQuote((String)infoList.get(7)));				// お知らせ８
//			if(!isMineoTandoku)
//			{
//				sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))			// お問合せ先１
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))				// お問合せ先２
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))				// お問合せ先３
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD04)))				// お問合せ先４
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))				// お問合せ先５
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));				// お問合せ先６
//			}
//			else
//			{
//				sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV01)))			// お問合せ先１
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV02)))				// お問合せ先２
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV03)))				// お問合せ先３
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV04)))				// お問合せ先４
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)))				// お問合せ先５
//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV06)));				// お問合せ先６
//			}
//
//			sb.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM)))						// 料金内訳
//			.append(CSV + getStringToDblQuote(strAmnt))			// 金額
//			.append(CSV + getStringToDblQuote(strUwAmnt))		// 金額内訳
//			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT)))				// 請求額
//			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT)))				// 請求額
//			.append(CSV + getStringToDblQuote(JACStrConst.OCR_VER_INFO))		// バージョン番号
//			.append(CSV + getStringToDblQuote(strOcr))			// OCR
//
//			.append(CSV + getStringToDblQuote(payYear))			// 支払期限日（年）
//			.append(CSV + getStringToDblQuote(payMonth))		// 支払期限日（月）
//			.append(CSV + getStringToDblQuote(payDay))			// 支払期限日（日）
//			
//			//OM-2014-0003652 MOD START
////			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_EAN_BARCODE)))			// EANバーコード
//			.append(CSV + getStringToDblQuote(eanBarcode))			// EANバーコード
//			//OM-2014-0003652 MOD END
//
//			.append(CSV + getStringToDblQuote(eanMonth))			// コンビニ支払期限月
//			.append(CSV + getStringToDblQuote(eanDay))				// コンビニ支払期限日
//
//			.append(CSV + getStringToDblQuote(shInsHrtkMask))		// 収入印紙貼付欄マスク
//
//// 2014.06.04 OM-2014-0001921 add start
//			.append(CSV + getStringToDblQuote(strAddress1[1]))			// 送付住所1-2
//			.append(CSV + getStringToDblQuote(strAddress2[1]))			// 送付住所2-2
//			.append(CSV + getStringToDblQuote(strAddress3[1]))			// 送付住所3-2
//			.append(CSV + getStringToDblQuote(strAddress4[1]))			// 送付住所4-2
//// 2014.06.04 OM-2014-0001921 add end
//
//			.append(System.getProperty(LINE_SEP));
//		}
//		return sb.toString().getBytes("UTF-8");
//	}
	// ANK-3838-00-00 DEL END

	// ANK-3838-00-00 ADD START
	/**
	 * ご利用料金請求書(窓口／コンビニ・銀行)情報をCSV形式のバイナリデータに変換する。
	 * @param param
	 * @param bothDispMap 内訳両出力マップ
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private byte[] makeCSVDataUsePrcSeikyshoMadoConvBank(IRequestParameterReadWrite param, HashMap<String, String> bothDispMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		ArrayList childList = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List");
		
		// 業務パラメータ管理情報取得
		HashMap<String, String> workParamMap = getWorkParamKnri(param);
		
		StringBuffer sb = new StringBuffer();
		
		// フォーマット編集
		String zuijiFlg = (String)parentMapCC.get("zuijiFlg");
		
		// 送付先郵便番号
		String sohusPcd = JACStrConst.KARA_MOJI;
		if(ZUIJI_FLG.equals(zuijiFlg))
		{
			ArrayList seikyKeiykList = (ArrayList)parentMapCC.get("seikyKeiykList");
			HashMap<String, Object> seikyKeiykMap = (HashMap<String, Object>)seikyKeiykList.get(0);
			sohusPcd = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD);
		}
		else
		{
			sohusPcd = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD);
		}
		
		// 通常文字サイズ か 小さい文字サイズ かのフラグ
		HashMap<String, String> editFlgMap = new HashMap<String, String>();
		
		// 送付先
		ArrayList<String> addressList = editSohusaki(parentMapCC, editFlgMap);
		
		// 住所リストから更新用住所配列を取得
		String[] strAddress1 = getAddressArray(addressList.get(0), editFlgMap);
		String[] strAddress2 = getAddressArray(addressList.get(1), editFlgMap);
		String[] strAddress3 = getAddressArray(addressList.get(2), editFlgMap);
		String[] strAddress4 = getAddressArray(addressList.get(3), editFlgMap);
		
		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);
		
		// カスタマバーコード
		String customerBarCd = editOutputCustomerBarCd(parentMapCC);
		
		// 発行番号
		//String hakkoNum = editHakkoNo(parentMapCC);
		
		// 発行日←オンライン運用日付
		String hakkoYmd = JCCBPCommon.getOnlineOpeDate(null);
		String hakkoYear = editYmd(hakkoYmd, DATE_KBN_YEAR);
		String hakkoMonth = editYmd(hakkoYmd, DATE_KBN_MON);
		String hakkoDay = editYmd(hakkoYmd, DATE_KBN_DAY);
		
		// ご請求年月月
		String seikyYm = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM)).trim();
		String seikyYear = editYmd(seikyYm, DATE_KBN_YEAR);
		String seikyMonth = editYmd(seikyYm, DATE_KBN_MON);
		
		// 請求書発行番号
		String seikyshoHakkoNo = seikyYm.substring(2,6) + "-" + (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO);
		
		// 支払期限日
		String payYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.PAY_KIGEN_YMD)).trim();
		String payYear = editYmd(payYmd, DATE_KBN_YEAR);
		String payMonth = editYmd(payYmd, DATE_KBN_MON);
		String payDay = editYmd(payYmd, DATE_KBN_DAY);
		
		// EAN取扱期限年月日
		String eanYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.HANDING_KIGEN_YMD)).trim();
		
		String eanMonth = new String();
		String eanDay = new String();
		
		eanMonth = editZeroSpace(editYmd(eanYmd, DATE_KBN_MON));
		eanDay = editZeroSpace((editYmd(eanYmd, DATE_KBN_DAY)));
		
		String strweek = this.getDayOfWeek(payYmd);
		
		// OCR番号をスキーマから取得
		String ocrNo = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_OCR_NO);
		
		String strOcr = JACStrConst.KARA_MOJI;
		if(!(ocrNo == null || JACStrConst.KARA_MOJI.equals(ocrNo)))
		{
			// OCR番号
			strOcr = ocrNo.substring(0, 32);
		}
		
		// お知らせ
		ArrayList<String> infoList = editInformation(parentMapCC);
		
		// 印紙税対象額を「発行日」を基準日として取得する
		long inshiTaxTgAmnt = Long.valueOf(JCHStampDutyUtil.getTaxableAmount(JACStrConst.CALLER_SCREEN, null, hakkoYmd));
		
		// 収入印紙貼付欄マスク
		String shInsHrtkMask  = JACStrConst.KARA_MOJI;
		
		long seikyAmnt = Long.parseLong((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT));
		if(seikyAmnt < inshiTaxTgAmnt)
		{
			// 印紙税対象ではない
			shInsHrtkMask = SN_INS_HRTK_MASK_AST;
		}
		
		// うち消費税を取得
		String tax = getZeiAmnt(param, LIST_KBN_MADO);
		
		// EANバーコード
		String eanBarcode = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_EAN_BARCODE);
		
		if(eanBarcode == null)
		{
			eanBarcode = JACStrConst.KARA_MOJI;
		}
		else
		{
			eanBarcode = eanBarcode.trim();
		}
		
		if(JACStrConst.EAN_SKBTS_XX.equals(eanBarcode))
		{
			eanBarcode = JACStrConst.KARA_MOJI;
		}
		
		HashMap<String, Object> msg_next = null;
		// 明細行形成
		for(int i = 0; i < childList.size(); i++) 
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);
			msg_next = null;//初期化
			
			if(i + 1 < childList.size())
			{
				msg_next = (HashMap<String, Object>)childList.get(i + 1);
			}
			
			// 金額
			String strAmnt = new String();
			// 金額内訳
			String strUwAmnt = new String();
			// 金額表示カラム数
			String amntDspColumCnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT);
			
			// 料金グループコード
			String prcGrpCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
			// 料金コースコード
			String pcrsCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
			// 料金サービスコード
			String prcSvcCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
			// 料金項目コード
			String prcKmkCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
			
			// 請求内訳両出力判定キー
			StringBuilder prcKmkKey = new StringBuilder();
			prcKmkKey.append(prcGrpCd).append(pcrsCd).append(prcSvcCd).append(prcKmkCd);
			
			//mineo単独の場合
			boolean isMineoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MINEO_TANDOKU);
			
//ANK-4595-01-00 ADD START
			//eo電気単独の場合
			boolean isElectTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.ELEC_TANDOKU);
			//マンションオーナーの場合
			boolean isMtonTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MTON_TANDOKU);
//ANK-4595-01-00 ADD END
//ANK-4427-00-00 ADD START
			//NTT卸単独の場合
			boolean isNttoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.NTTO_TANDOKU);
//ANK-4427-00-00 ADD END

			// 料金項目コードが業務機能識別コード(請求内訳両出力)に存在する場合、金額、金額内訳両方に出力する
			if (bothDispMap.containsKey(prcKmkKey.toString()))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				
				if(msg_next == null || JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT.equals((String)msg_next.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT)))
				{
					// 金額内訳
					strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				}
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_ID_NO_SUM))
			{
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else
			{
				// 内訳額
				strAmnt = new String();
				// 金額内訳
				strUwAmnt = new String();
			}
			
			sb.append(getStringToDblQuote(sohusPcd))						// 郵便番号
			.append(CSV + getStringToDblQuote(strAddress1[0]))				// 送付住所1-1
			.append(CSV + getStringToDblQuote(strAddress2[0]))				// 送付住所1-2
			.append(CSV + getStringToDblQuote(strAddress3[0]))				// 送付住所1-3
			.append(CSV + getStringToDblQuote(strAddress4[0]))				// 送付住所1-4
			.append(CSV + getStringToDblQuote(strAddress1[1]))				// 送付住所2-1
			.append(CSV + getStringToDblQuote(strAddress2[1]))				// 送付住所2-2
			.append(CSV + getStringToDblQuote(strAddress3[1]))				// 送付住所2-3
			.append(CSV + getStringToDblQuote(strAddress4[1]))				// 送付住所2-4
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(0)))	// お客さま名１(送付先名)
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))	// お客さま名２(送付先部署名)
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))	// お客さま名３(送付先担当者名)
			.append(CSV + getStringToDblQuote(customerBarCd))				// カスタマーバーコード
			.append(CSV + getStringToDblQuote(seikyshoHakkoNo))				// 請求書発行番号
			.append(CSV + getStringToDblQuote(hakkoYear))					// 発行年月日（年）
			.append(CSV + getStringToDblQuote(hakkoMonth))					// 発行年月日（月）
			.append(CSV + getStringToDblQuote(hakkoDay))					// 発行年月日（日）
			.append(CSV + getStringToDblQuote(seikyYear))					// 請求月（年）
			.append(CSV + getStringToDblQuote(seikyMonth))					// 請求月（月）
			.append(CSV + getStringToDblQuote(editStr((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT),12)))	// 請求額
			.append(CSV + getStringToDblQuote(tax))							// うち消費税
			.append(CSV + getStringToDblQuote(payYear))						// 支払期限日（年）
			.append(CSV + getStringToDblQuote(payMonth))					// 支払期限日（月）
			.append(CSV + getStringToDblQuote(payDay))						// 支払期限日（日）
			.append(CSV + getStringToDblQuote(strweek))						// 支払期限日（曜日）
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)));	// お客様番号

//ANK-4595-01-00 MOD START
//			if(!isMineoTandoku)
			//mineo単独以外　かつ　電気単独以外　かつ　マンションオーナー以外の場合
//ANK-4427-00-00 MOD START
			//if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku)
			////mineo単独以外　かつ　電気単独以外　かつ　マンションオーナー以外　且つ　NTT卸単独以外の場合
			if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku && !isNttoTandoku)
//ANK-4427-00-00 MOD END
//ANK-4595-01-00 MOD END
			{
				sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))				// お問合せ先１
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))					// お問合せ先２
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))					// お問合せ先３
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))					// お問合せ先４
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));					// お問合せ先５
			}
			else
			{
//ANK-4595-01-00 ADD START
				//mineo単独の場合
				if(isMineoTandoku &&!isElectTandoku)
				{	
//ANK-4595-01-00 ADD END
					sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV01)))				// お問合せ先１
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV02)))					// お問合せ先２
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV03)))					// お問合せ先３
					// ANK-4326-00-00 MOD START
	//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)))					// お問合せ先４
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)));					// お問合せ先４
					
					 
					if (tiawaseKirikaeDay.compareTo(hakkoYmd) > 0) 
					{ // 運用日が2022/12/11 より前の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV06)));			// お問合せ先５（旧）
					}
					else 
					{ // 運用日が2022/12/11 以降の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV07)));			// お問合せ先５（新）
					}
					// ANK-4326-00-00 MOD END
				}else{
//ANK-4595-01-00 ADD START					
					//eo電気単独の場合
					if(isElectTandoku &&!isMineoTandoku )
					{
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL01)))				// お問合せ先１
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL02)))					// お問合せ先２
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL03)))					// お問合せ先３
//IT2-2024-0000014 MOD START
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL04)))					// お問合せ先４
//IT2-2024-0000014 MOD END
//IT2-2024-0000013 MOD START
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)))					// お問合せ先５
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL06)));					// お問合せ先６
//IT2-2024-0000014 MOD START
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)));					// お問合せ先５
//IT2-2024-0000013 MOD END
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)))					// お問合せ先５
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL06)));					// お問合せ先６
//IT2-2024-0000014 MOD END
					}else
					{
						//マンションオーナーの場合
						if(isMtonTandoku)
						{
//IT2-2024-0000014 ADD START
							//お問合せ先５+お問合せ先６を文字列結合
							String toiawasesk = "";	
							if(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05) == null || workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06) == null ){
								toiawasesk = workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05) + workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06);
							}else
							{
								toiawasesk = workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05) + workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06).substring(2);
							}
//IT2-2024-0000014 ADD END
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT02)))					// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT03)))					// お問合せ先３
//IT2-2024-0000014 MOD START
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT04)))					// お問合せ先４
//							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05)))					// お問合せ先５
//							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06)));					// お問合せ先６
							.append(CSV + getStringToDblQuote(toiawasesk));																//	お問合せ先５+お問合せ先６
//IT2-2024-0000014 MOD END
						}
						//mieno単独であり電気単独である場合
						if(isMineoTandoku && isElectTandoku){
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))					// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))					// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))					// お問合せ先４
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));					// お問合せ先５
						}
	//ANK-4427-00-00 ADD START
						//NTT卸単独の場合
						if(isNttoTandoku){
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT02)))					// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT03)))					// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT05)))					// お問合せ先５
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT06)));				// お問合せ先６
						}
	//ANK-4427-00-00 ADD END
					}
				}
//ANK-4595-01-00 ADD END
			}
			
			// お知らせ文言
			sb.append(CSV + getStringToDblQuote((String)infoList.get(0)))	// お知らせ文言１
			.append(CSV + getStringToDblQuote((String)infoList.get(1)))		// お知らせ文言２
			.append(CSV + getStringToDblQuote((String)infoList.get(2)))		// お知らせ文言３
			.append(CSV + getStringToDblQuote((String)infoList.get(3)))		// お知らせ文言４
			.append(CSV + getStringToDblQuote((String)infoList.get(4)))		// お知らせ文言５
			.append(CSV + getStringToDblQuote((String)infoList.get(5)))		// お知らせ文言６
			.append(CSV + getStringToDblQuote((String)infoList.get(6)))		// お知らせ文言７
			.append(CSV + getStringToDblQuote((String)infoList.get(7)))		// お知らせ文言８
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM)))					// 料金内訳名称
			.append(CSV + getStringToDblQuote(editStr(strAmnt, 9)))			// 金額
			.append(CSV + getStringToDblQuote(editStr(strUwAmnt, 9)))		// 金額内訳
			.append(CSV + getStringToDblQuote(editStr((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT), 9)))	// 合計金額(請求額)
			.append(CSV + getStringToDblQuote(editStr((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT), 9)))	// 内訳合計金額(請求額)
			.append(CSV + getStringToDblQuote(JACStrConst.OCR_VER_INFO))	// OCRバージョン情報
			.append(CSV + getStringToDblQuote(strOcr))						// OCR
			.append(CSV + getStringToDblQuote(eanBarcode))					// EANバーコード
			.append(CSV + getStringToDblQuote(eanMonth))					// コンビニ支払期限月
			.append(CSV + getStringToDblQuote(eanDay))						// コンビニ支払期限日
			.append(CSV + getStringToDblQuote(tax))							// 内消費税
			.append(CSV + getStringToDblQuote(shInsHrtkMask))				// 収入印紙貼付欄マスク
			.append(System.getProperty(LINE_SEP));
		}
		return sb.toString().getBytes("UTF-8");
	}

	/**
	 * ご利用料金請求書(窓口／コンビニ)情報をCSV形式のバイナリデータに変換する。
	 * @param param
	 * @param bothDispMap 内訳両出力マップ
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private byte[] makeCSVDataUsePrcSeikyshoMadoCnv(IRequestParameterReadWrite param, HashMap<String, String> bothDispMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		ArrayList childList = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List");
		
		// 業務パラメータ管理情報取得
		HashMap<String, String> workParamMap = getWorkParamKnri(param);
		
		StringBuffer sb = new StringBuffer();
		
		// フォーマット編集
		String zuijiFlg = (String)parentMapCC.get("zuijiFlg");
		
		// 送付先郵便番号
		String sohusPcd = JACStrConst.KARA_MOJI;
		if(ZUIJI_FLG.equals(zuijiFlg))
		{
			ArrayList seikyKeiykList = (ArrayList)parentMapCC.get("seikyKeiykList");
			HashMap<String, Object> seikyKeiykMap = (HashMap<String, Object>)seikyKeiykList.get(0);
			sohusPcd = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD);
		}
		else
		{
			sohusPcd = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD);
		}
		
		// 通常文字サイズ か 小さい文字サイズ かのフラグ
		HashMap<String, String> editFlgMap = new HashMap<String, String>();
		
		// 送付先
		ArrayList<String> addressList = editSohusaki(parentMapCC, editFlgMap);
		
		// 住所リストから更新用住所配列を取得
		String[] strAddress1 = getAddressArray(addressList.get(0), editFlgMap);
		String[] strAddress2 = getAddressArray(addressList.get(1), editFlgMap);
		String[] strAddress3 = getAddressArray(addressList.get(2), editFlgMap);
		String[] strAddress4 = getAddressArray(addressList.get(3), editFlgMap);
		
		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);
		
		// カスタマバーコード
		String customerBarCd = editOutputCustomerBarCd(parentMapCC);
		
		// 発行番号
		//String hakkoNum = editHakkoNo(parentMapCC);
		
		// 発行日←オンライン運用日付
		String hakkoYmd = JCCBPCommon.getOnlineOpeDate(null);
		String hakkoYear = editYmd(hakkoYmd, DATE_KBN_YEAR);
		String hakkoMonth = editYmd(hakkoYmd, DATE_KBN_MON);
		String hakkoDay = editYmd(hakkoYmd, DATE_KBN_DAY);
		
		// ご請求年月月
		String seikyYm = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM)).trim();
		String seikyYear = editYmd(seikyYm, DATE_KBN_YEAR);
		String seikyMonth = editYmd(seikyYm, DATE_KBN_MON);
		
		// 請求書発行番号
		String seikyshoHakkoNo = seikyYm.substring(2,6) + "-" + (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO);
		
		// 支払期限日
		String payYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.PAY_KIGEN_YMD)).trim();
		String payYear = editYmd(payYmd, DATE_KBN_YEAR);
		String payMonth = editYmd(payYmd, DATE_KBN_MON);
		String payDay = editYmd(payYmd, DATE_KBN_DAY);
		
		// EAN取扱期限年月日
		String eanYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.HANDING_KIGEN_YMD)).trim();
		
		String eanMonth = new String();
		String eanDay = new String();
		
		eanMonth = editZeroSpace(editYmd(eanYmd, DATE_KBN_MON));
		eanDay = editZeroSpace((editYmd(eanYmd, DATE_KBN_DAY)));
		
		String strweek = this.getDayOfWeek(payYmd);
		
		// お知らせ
		ArrayList<String> infoList = editInformation(parentMapCC);
		
		// 印紙税対象額を「発行日」を基準日として取得する
		long inshiTaxTgAmnt = Long.valueOf(JCHStampDutyUtil.getTaxableAmount(JACStrConst.CALLER_SCREEN, null, hakkoYmd));
		
		// 収入印紙貼付欄マスク
		String shInsHrtkMask  = JACStrConst.KARA_MOJI;
		
		long seikyAmnt = Long.parseLong((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT));
		if(seikyAmnt < inshiTaxTgAmnt)
		{
			// 印紙税対象ではない
			shInsHrtkMask = SN_INS_HRTK_MASK_AST;
		}
		
		// うち消費税を取得
		String tax = getZeiAmnt(param, LIST_KBN_MADO);
		
		// EANバーコード
		String eanBarcode = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_EAN_BARCODE);
		
		if(eanBarcode == null)
		{
			eanBarcode = JACStrConst.KARA_MOJI;
		}
		else
		{
			eanBarcode = eanBarcode.trim();
		}
		
		if(JACStrConst.EAN_SKBTS_XX.equals(eanBarcode))
		{
			eanBarcode = JACStrConst.KARA_MOJI;
		}
		
		HashMap<String, Object> msg_next = null;
		// 明細行形成
		for(int i = 0; i < childList.size(); i++) 
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);
			msg_next = null;//初期化
			
			if(i + 1 < childList.size())
			{
				msg_next = (HashMap<String, Object>)childList.get(i + 1);
			}
			
			// 金額
			String strAmnt = new String();
			// 金額内訳
			String strUwAmnt = new String();
			// 金額表示カラム数
			String amntDspColumCnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT);
			
			// 料金グループコード
			String prcGrpCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
			// 料金コースコード
			String pcrsCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
			// 料金サービスコード
			String prcSvcCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
			// 料金項目コード
			String prcKmkCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
			
			// 請求内訳両出力判定キー
			StringBuilder prcKmkKey = new StringBuilder();
			prcKmkKey.append(prcGrpCd).append(pcrsCd).append(prcSvcCd).append(prcKmkCd);
			
			//mineo単独の場合
			boolean isMineoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MINEO_TANDOKU);

//ANK-4595-01-00 ADD START
			//eo電気単独の場合
			boolean isElectTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.ELEC_TANDOKU);
			//マンションオーナーの場合
			boolean isMtonTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MTON_TANDOKU);
//ANK-4595-01-00 ADD END			
//ANK-4427-00-00 ADD START
			//NTT卸の場合
			boolean isNttoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.NTTO_TANDOKU);
//ANK-4427-00-00 ADD END			
			// 料金項目コードが業務機能識別コード(請求内訳両出力)に存在する場合、金額、金額内訳両方に出力する
			if (bothDispMap.containsKey(prcKmkKey.toString()))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				
				if(msg_next == null || JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT.equals((String)msg_next.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT)))
				{
					// 金額内訳
					strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				}
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_ID_NO_SUM))
			{
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else
			{
				// 内訳額
				strAmnt = new String();
				// 金額内訳
				strUwAmnt = new String();
			}
			
			sb.append(getStringToDblQuote(sohusPcd))						// 郵便番号
			.append(CSV + getStringToDblQuote(strAddress1[0]))				// 送付住所1-1
			.append(CSV + getStringToDblQuote(strAddress2[0]))				// 送付住所1-2
			.append(CSV + getStringToDblQuote(strAddress3[0]))				// 送付住所1-3
			.append(CSV + getStringToDblQuote(strAddress4[0]))				// 送付住所1-4
			.append(CSV + getStringToDblQuote(strAddress1[1]))				// 送付住所2-1
			.append(CSV + getStringToDblQuote(strAddress2[1]))				// 送付住所2-2
			.append(CSV + getStringToDblQuote(strAddress3[1]))				// 送付住所2-3
			.append(CSV + getStringToDblQuote(strAddress4[1]))				// 送付住所2-4
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(0)))	// お客さま名１(送付先名)
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))	// お客さま名２(送付先部署名)
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))	// お客さま名３(送付先担当者名)
			.append(CSV + getStringToDblQuote(customerBarCd))				// カスタマーバーコード
			.append(CSV + getStringToDblQuote(seikyshoHakkoNo))				// 請求書発行番号
			.append(CSV + getStringToDblQuote(hakkoYear))					// 発行年月日（年）
			.append(CSV + getStringToDblQuote(hakkoMonth))					// 発行年月日（月）
			.append(CSV + getStringToDblQuote(hakkoDay))					// 発行年月日（日）
			.append(CSV + getStringToDblQuote(seikyYear))					// 請求月（年）
			.append(CSV + getStringToDblQuote(seikyMonth))					// 請求月（月）
			.append(CSV + getStringToDblQuote(editStr((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT), 12)))	// 請求額
			.append(CSV + getStringToDblQuote(tax))							// うち消費税
			.append(CSV + getStringToDblQuote(payYear))						// 支払期限日（年）
			.append(CSV + getStringToDblQuote(payMonth))					// 支払期限日（月）
			.append(CSV + getStringToDblQuote(payDay))						// 支払期限日（日）
			.append(CSV + getStringToDblQuote(strweek))						// 支払期限日（曜日）
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)));	// お客様番号
			
//ANK-4595-01-00 MOD START
//			if(!isMineoTandoku)
			//mineo単独以外　かつ　eo電気単独以外　かつ　マンションオーナー以外の場合
//ANK-4427-00-00 MOD START
			//if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku)
			////mineo単独以外　かつ　電気単独以外　かつ　マンションオーナー以外　且つ　NTT卸単独以外の場合
			if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku && !isNttoTandoku)
//ANK-4427-00-00 MOD END
//ANK-4595-01-00 MOD END
			{
				sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))				// お問合せ先１
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))					// お問合せ先２
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))					// お問合せ先３
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))					// お問合せ先４
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));					// お問合せ先５
			}
			else
			{
//ANK-4595-01-00 ADD START
				//mineo単独の場合
				if(isMineoTandoku && !isElectTandoku)
				{
//ANK-4595-01-00 ADD END
					sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV01)))				// お問合せ先１
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV02)))					// お問合せ先２
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV03)))					// お問合せ先３
					// ANK-4326-00-00 MOD START
	//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)))					// お問合せ先４
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)));					// お問合せ先４
					
					if (tiawaseKirikaeDay.compareTo(hakkoYmd) > 0) 
					{ // 運用日が2022/12/11 より前の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV06)));			// お問合せ先５（旧）
					}
					else 
					{ // 運用日が2022/12/11 以降の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV07)));			// お問合せ先５（新）
					}
					// ANK-4326-00-00 MOD END
//ANK-4595-01-00 ADD START
				}
//ANK-4595-01-00 ADD END
				else
				{
//ANK-4595-01-00 ADD START
					//eo電気の場合
					if(isElectTandoku && !isMineoTandoku)
					{
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL01)))				// お問合せ先１
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL02)))					// お問合せ先２
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL03)))					// お問合せ先３
//IT2-2024-0000014　MOD START
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL04)))					// お問合せ先４
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)));					// お問合せ先５
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)))					// お問合せ先５
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL06)));					// お問合せ先６
//IT2-2024-0000014 MOD END
					}else
					{
						//マンションオーナーの場合
						if(isMtonTandoku)
						{
//IT2-2024-0000014 ADD START
							//お問合せ先５+お問合せ先６を文字列結合
							String toiawasesk = "";
							if(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05) == null || workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06) == null)
							{
								toiawasesk = workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05) + workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06);
							}else
							{
								toiawasesk = workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05) + workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06).substring(2);
							}	
//IT2-2024-0000014 ADD END
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT02)))					// お問合せ先２
//IT2-2024-0000013 ADD START
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT03)))					// お問合せ先３
//IT2-2024-0000013 ADD END
//IT2-2024-0000014 MOD START							
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT04)))					// お問合せ先４
//							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05)))					// お問合せ先５
//							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06)));					// お問合せ先６

							.append(CSV + getStringToDblQuote(toiawasesk));																	//	お問合せ先５+お問合せ先６
//IT2-2024-0000014 MOD END
						}
						//mieno単独であり電気単独である場合
						if(isMineoTandoku && isElectTandoku)
						{
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))					// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))					// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))					// お問合せ先４
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));					// お問合せ先５
						}
	//ANK-4427-00-00 ADD START
						//NTT卸単独の場合
						if(isNttoTandoku){
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT02)))					// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT03)))					// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT05)))					// お問合せ先５
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT06)));				// お問合せ先６
						}
	//ANK-4427-00-00 ADD END
					}
//ANK-4595-01-00 ADD END
				}
			}
			
			// お知らせ文言
			sb.append(CSV + getStringToDblQuote((String)infoList.get(0)))	// お知らせ文言１
			.append(CSV + getStringToDblQuote((String)infoList.get(1)))		// お知らせ文言２
			.append(CSV + getStringToDblQuote((String)infoList.get(2)))		// お知らせ文言３
			.append(CSV + getStringToDblQuote((String)infoList.get(3)))		// お知らせ文言４
			.append(CSV + getStringToDblQuote((String)infoList.get(4)))		// お知らせ文言５
			.append(CSV + getStringToDblQuote((String)infoList.get(5)))		// お知らせ文言６
			.append(CSV + getStringToDblQuote((String)infoList.get(6)))		// お知らせ文言７
			.append(CSV + getStringToDblQuote((String)infoList.get(7)))		// お知らせ文言８
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM)))					// 料金内訳名称
			.append(CSV + getStringToDblQuote(editStr(strAmnt, 9)))			// 金額
			.append(CSV + getStringToDblQuote(editStr(strUwAmnt, 9)))		// 金額内訳
			.append(CSV + getStringToDblQuote(editStr((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT), 9)))			// 合計金額(請求額)
			.append(CSV + getStringToDblQuote(eanBarcode))					// EANバーコード
			.append(CSV + getStringToDblQuote(eanMonth))					// コンビニ支払期限月
			.append(CSV + getStringToDblQuote(eanDay))						// コンビニ支払期限日
			.append(CSV + getStringToDblQuote(tax))							// 内消費税
			.append(CSV + getStringToDblQuote(shInsHrtkMask))				// 収入印紙貼付欄マスク
			.append(System.getProperty(LINE_SEP));
		}
		return sb.toString().getBytes("UTF-8");
	}

	/**
	 * ご利用料金請求書(窓口／コンビニ・パーフェクト)情報をCSV形式のバイナリデータに変換する。
	 * @param param
	 * @param bothDispMap 内訳両出力マップ
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private byte[] makeCSVDataUsePrcSeikyshoMadoConvPerf(IRequestParameterReadWrite param, HashMap<String, String> bothDispMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		ArrayList childList = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List");
		
		// 業務パラメータ管理情報取得
		HashMap<String, String> workParamMap = getWorkParamKnri(param);
		
		StringBuffer sb = new StringBuffer();
		
		// フォーマット編集
		String zuijiFlg = (String)parentMapCC.get("zuijiFlg");
		
		// 送付先郵便番号
		String sohusPcd = JACStrConst.KARA_MOJI;
		if(ZUIJI_FLG.equals(zuijiFlg))
		{
			ArrayList seikyKeiykList = (ArrayList)parentMapCC.get("seikyKeiykList");
			HashMap<String, Object> seikyKeiykMap = (HashMap<String, Object>)seikyKeiykList.get(0);
			sohusPcd = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD);
		}
		else
		{
			sohusPcd = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD);
		}
		
		// 通常文字サイズ か 小さい文字サイズ かのフラグ
		HashMap<String, String> editFlgMap = new HashMap<String, String>();
		
		// 送付先
		ArrayList<String> addressList = editSohusaki(parentMapCC, editFlgMap);
		
		// 住所リストから更新用住所配列を取得
		String[] strAddress1 = getAddressArray(addressList.get(0), editFlgMap);
		String[] strAddress2 = getAddressArray(addressList.get(1), editFlgMap);
		String[] strAddress3 = getAddressArray(addressList.get(2), editFlgMap);
		String[] strAddress4 = getAddressArray(addressList.get(3), editFlgMap);
		
		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);
		
		// カスタマバーコード
		String customerBarCd = editOutputCustomerBarCd(parentMapCC);
		
		// 発行番号
//		String hakkoNum = editHakkoNo(parentMapCC);
		
		// 発行日←オンライン運用日付
		String hakkoYmd = JCCBPCommon.getOnlineOpeDate(null);
		String hakkoYear = editYmd(hakkoYmd, DATE_KBN_YEAR);
		String hakkoMonth = editYmd(hakkoYmd, DATE_KBN_MON);
		String hakkoDay = editYmd(hakkoYmd, DATE_KBN_DAY);
		
		// ご請求年月月
		String seikyYm = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM)).trim();
		String seikyYear = editYmd(seikyYm, DATE_KBN_YEAR);
		String seikyMonth = editYmd(seikyYm, DATE_KBN_MON);
		
		// 請求書発行番号
		String seikyshoHakkoNo = seikyYm.substring(2,6) + "-" + (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO);
		
		// 支払期限日
		String payYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.PAY_KIGEN_YMD)).trim();
		String payYear = editYmd(payYmd, DATE_KBN_YEAR);
		String payMonth = editYmd(payYmd, DATE_KBN_MON);
		String payDay = editYmd(payYmd, DATE_KBN_DAY);
		
		// EAN取扱期限年月日
		String eanYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.HANDING_KIGEN_YMD)).trim();
		
		String eanMonth = new String();
		String eanDay = new String();
		
		eanMonth = editZeroSpace(editYmd(eanYmd, DATE_KBN_MON));
		eanDay = editZeroSpace((editYmd(eanYmd, DATE_KBN_DAY)));
		
		String strweek = this.getDayOfWeek(payYmd);
		
		// お知らせ
		ArrayList<String> infoList = editInformation(parentMapCC);
		
		// 印紙税対象額を「発行日」を基準日として取得する
		long inshiTaxTgAmnt = Long.valueOf(JCHStampDutyUtil.getTaxableAmount(JACStrConst.CALLER_SCREEN, null, hakkoYmd));
		
		// 収入印紙貼付欄マスク
		String shInsHrtkMask  = JACStrConst.KARA_MOJI;
		
		long seikyAmnt = Long.parseLong((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT));
		if(seikyAmnt < inshiTaxTgAmnt)
		{
			// 印紙税対象ではない
			shInsHrtkMask = SN_INS_HRTK_MASK_AST;
		}
		
		// うち消費税を取得
		String tax = getZeiAmnt(param, LIST_KBN_MADO);
		
		// EANバーコード
		String eanBarcode = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_MADOGUCHI_EAN_BARCODE);
		
		if(eanBarcode == null)
		{
			eanBarcode = JACStrConst.KARA_MOJI;
		}
		else
		{
			eanBarcode = eanBarcode.trim();
		}
		
		if(JACStrConst.EAN_SKBTS_XX.equals(eanBarcode))
		{
			eanBarcode = JACStrConst.KARA_MOJI;
		}
		
		// パーフェクト口座振込先銀行名
		String pkozaHrikomiSakiBankNm = "";
		// パーフェクト口座支店名
		String pkozaShitenNm = "";
		// パーフェクト口座種目
		String pkozaShumoku = "";
		// パーフェクト口座番号
		String pkozaNo = "";
		// パーフェクト口座利用有無
		String pkozaUseUm = "";
		
		// パーフェクト口座一意照会の結果を取得する
		ArrayList childList2 = (ArrayList)parentMapCC.get("ECH0941A010CBSMsg1List");
		if (childList2 != null && childList2.size() > 0)
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)childList2.get(0);
			
			if (msg != null)
			{
				// パーフェクト口座番号
				pkozaNo = (String)msg.get(JCHTushinSvcConstCC.ECH0941A010_PKOZA_NO);
				// パーフェクト口座利用有無
				pkozaUseUm = (String)msg.get(JCHTushinSvcConstCC.ECH0941A010_PKOZA_USE_UM);
				
				// パーフェクト口座利用判定
				// パーフェクト口座が""(空)ではない、かつ、パーフェクト口座利用有無が"1"(利用する)の場合
				if ((pkozaNo != null && !"".equals(pkozaNo)) && (pkozaUseUm != null && "1".equals(pkozaUseUm)))
				{
					// パーフェクト口座振込先銀行名
					pkozaHrikomiSakiBankNm = JACCommonUtil.editStrLength((String)msg.get(JCHTushinSvcConstCC.ECH0941A010_PKOZA_BANK_NM), CHOHYO_OUT_BANK_NM_LENGTH);
					// パーフェクト口座支店名
					pkozaShitenNm = JACCommonUtil.editStrLength((String)msg.get(JCHTushinSvcConstCC.ECH0941A010_PKOZA_SHITEN_NM), CHOHYO_OUT_BANK_SHITEN_NM_LENGTH);
					// パーフェクト口座種目
					pkozaShumoku = JACStrConst.PKOZA_SHUMOKU_HUTSU;
				}
				// 利用しない場合はパーフェクト口座情報は全て空で設定する
				else
				{
					// パーフェクト口座振込先銀行名
					pkozaHrikomiSakiBankNm = "";
					// パーフェクト口座支店名
					pkozaShitenNm = "";
					// パーフェクト口座種目
					pkozaShumoku = "";
					// パーフェクト口座番号
					pkozaNo = "";
				}
			}
		}
		
		HashMap<String, Object> msg_next = null;
		// 明細行形成
		for(int i = 0; i < childList.size(); i++) 
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);
			msg_next = null;//初期化
			
			if(i + 1 < childList.size())
			{
				msg_next = (HashMap<String, Object>)childList.get(i + 1);
			}
			
			// 金額
			String strAmnt = new String();
			// 金額内訳
			String strUwAmnt = new String();
			// 金額表示カラム数
			String amntDspColumCnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT);
			
			// 料金グループコード
			String prcGrpCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
			// 料金コースコード
			String pcrsCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
			// 料金サービスコード
			String prcSvcCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
			// 料金項目コード
			String prcKmkCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
			
			// 請求内訳両出力判定キー
			StringBuilder prcKmkKey = new StringBuilder();
			prcKmkKey.append(prcGrpCd).append(pcrsCd).append(prcSvcCd).append(prcKmkCd);
			
			//mineo単独の場合
			boolean isMineoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MINEO_TANDOKU);
//ANK-4595-01-00 ADD STAR
			//eo電気単独の場合
			boolean isElectTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.ELEC_TANDOKU);
			//マンションオーナーの場合
			boolean isMtonTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MTON_TANDOKU);			
//ANK-4595-01-00 ADD END
//ANK-4427-00-00 ADD START
			//NTT卸単独の場合
			boolean isNttoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.NTTO_TANDOKU);
//ANK-4427-00-00 ADD END			
			// 料金項目コードが業務機能識別コード(請求内訳両出力)に存在する場合、金額、金額内訳両方に出力する
			if (bothDispMap.containsKey(prcKmkKey.toString()))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				
				if(msg_next == null || JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT.equals((String)msg_next.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT)))
				{
					// 金額内訳
					strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				}
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_ID_NO_SUM))
			{
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else
			{
				// 内訳額
				strAmnt = new String();
				// 金額内訳
				strUwAmnt = new String();
			}
			
			sb.append(getStringToDblQuote(sohusPcd))						// 郵便番号
			.append(CSV + getStringToDblQuote(strAddress1[0]))				// 送付住所1-1
			.append(CSV + getStringToDblQuote(strAddress2[0]))				// 送付住所1-2
			.append(CSV + getStringToDblQuote(strAddress3[0]))				// 送付住所1-3
			.append(CSV + getStringToDblQuote(strAddress4[0]))				// 送付住所1-4
			.append(CSV + getStringToDblQuote(strAddress1[1]))				// 送付住所2-1
			.append(CSV + getStringToDblQuote(strAddress2[1]))				// 送付住所2-2
			.append(CSV + getStringToDblQuote(strAddress3[1]))				// 送付住所2-3
			.append(CSV + getStringToDblQuote(strAddress4[1]))				// 送付住所2-4
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(0)))	// お客さま名１(送付先名)
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))	// お客さま名２(送付先部署名)
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))	// お客さま名３(送付先担当者名)
			.append(CSV + getStringToDblQuote(customerBarCd))				// カスタマーバーコード
			.append(CSV + getStringToDblQuote(seikyshoHakkoNo))				// 請求書発行番号
			.append(CSV + getStringToDblQuote(hakkoYear))					// 発行年月日（年）
			.append(CSV + getStringToDblQuote(hakkoMonth))					// 発行年月日（月）
			.append(CSV + getStringToDblQuote(hakkoDay))					// 発行年月日（日）
			.append(CSV + getStringToDblQuote(seikyYear))					// 請求月（年）
			.append(CSV + getStringToDblQuote(seikyMonth))					// 請求月（月）
			.append(CSV + getStringToDblQuote(editStr((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT), 12)))	// 請求額
			.append(CSV + getStringToDblQuote(tax))							// うち消費税
			.append(CSV + getStringToDblQuote(payYear))						// 支払期限日（年）
			.append(CSV + getStringToDblQuote(payMonth))					// 支払期限日（月）
			.append(CSV + getStringToDblQuote(payDay))						// 支払期限日（日）
			.append(CSV + getStringToDblQuote(strweek))						// 支払期限日（曜日）
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)));	// お客様番号
			
//ANK-4595-01-00 MOD START
//			if(!isMineoTandoku)
			//mineo単独以外　かつ　eo電気単独以外　かつ　マンションオーナー以外の場合
//ANK-4427-00-00 MOD START
			//if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku)
			////mineo単独以外　かつ　電気単独以外　かつ　マンションオーナー以外　且つ　NTT卸単独以外の場合
			if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku && !isNttoTandoku)
//ANK-4427-00-00 MOD END
//ANK-4595-01-00 MOD END
			{
				sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))				// お問合せ先１
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))					// お問合せ先２
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))					// お問合せ先３
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))					// お問合せ先４
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));					// お問合せ先５
			}
			else
			{
//ANK-4595-01-00 ADD START
				//mineo単独の場合
				if(isMineoTandoku && !isElectTandoku)
				{
//ANK-4595-01-00 ADD END
					sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV01)))				// お問合せ先１
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV02)))					// お問合せ先２
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV03)))					// お問合せ先３
					// ANK-4326-00-00 MOD START
	//				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)))					// お問合せ先４
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)));					// お問合せ先４
					 
					if (tiawaseKirikaeDay.compareTo(hakkoYmd) > 0) 
					{ // 運用日が2022/12/11 より前の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV06)));			// お問合せ先５（旧）
					}
					else 
					{ // 運用日が2022/12/11 以降の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV07)));			// お問合せ先５（新）
					}
				// ANK-4326-00-00 MOD END
//ANK-4595-01-00 ADD START
				}
				else{
					//eo電気単独の場合
					if(isElectTandoku && !isMineoTandoku)
					{
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL01)))				// お問合せ先１
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL02)))					// お問合せ先２
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL03)))					// お問合せ先３
//#85824 20241025 MOD START
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL04)))					// お問合せ先４
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)));					// お問合せ先５
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)))					// お問合せ先４
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL06)));					// お問合せ先５
//#85824 20241025 MOD END
					}
					else{
						//マンションオーナーの場合
						if(isMtonTandoku)
						{
//お問合せ先５+お問合せ先６を文字列結合処理を追加する
//#85824 20241025 ADD START
							//お問合せ先５+お問合せ先６を文字列結合
							String toiawasesk = "";
							if(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05) == null || workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06) == null)
							{
								toiawasesk = workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05) + workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06);
							}else
							{
								toiawasesk = workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05) + workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06).substring(2);
							}	
//#85824 20241025 ADD END
							
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT02)))					// お問合せ先２
//IT2-2024-0000013 ADD START
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT03)))					// お問合せ先３
//IT2-2024-0000013 ADD END
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT04)))					// お問合せ先４
//問い合わせ先5に文字列結合した問い合わせ先5を設定するように改修する
//OM-2024-000000XXXX 20241025 MOD START
//							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05)))					// お問合せ先５
//							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06)));					// お問合せ先６
							.append(CSV + getStringToDblQuote(toiawasesk));																//	お問合せ先５+お問合せ先６
//OM-2024-000000XXXX 20241025 MOD END
						}
						//mieno単独であり電気単独である場合
						if(isMineoTandoku && isElectTandoku)
						{
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))					// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))					// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))					// お問合せ先４
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));					// お問合せ先５
						}
	//ANK-4427-00-00 ADD START
						//NTT卸単独の場合
						if(isNttoTandoku){
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT02)))					// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT03)))					// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT05)))					// お問合せ先５
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT06)));				// お問合せ先６
						}
	//ANK-4427-00-00 ADD END
					}	
				}
//ANK-4595-01-00 ADD END
			}
			
			// お知らせ文言
			sb.append(CSV + getStringToDblQuote((String)infoList.get(0)))	// お知らせ文言１
			.append(CSV + getStringToDblQuote((String)infoList.get(1)))		// お知らせ文言２
			.append(CSV + getStringToDblQuote((String)infoList.get(2)))		// お知らせ文言３
			.append(CSV + getStringToDblQuote((String)infoList.get(3)))		// お知らせ文言４
			.append(CSV + getStringToDblQuote((String)infoList.get(4)))		// お知らせ文言５
			.append(CSV + getStringToDblQuote((String)infoList.get(5)))		// お知らせ文言６
			.append(CSV + getStringToDblQuote((String)infoList.get(6)))		// お知らせ文言７
			.append(CSV + getStringToDblQuote((String)infoList.get(7)))		// お知らせ文言８
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM)))					// 料金内訳名称
			.append(CSV + getStringToDblQuote(editStr(strAmnt, 9)))			// 金額
			.append(CSV + getStringToDblQuote(editStr(strUwAmnt, 9)))		// 金額内訳
			.append(CSV + getStringToDblQuote(editStr((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT), 9)))	// 合計金額(請求額)
			.append(CSV + getStringToDblQuote(editStr((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT), 9)))	// 内訳合計金額(請求額)
			.append(CSV + getStringToDblQuote(pkozaHrikomiSakiBankNm))		// 振込先銀行名
			.append(CSV + getStringToDblQuote(pkozaShitenNm))				// 支店名
			.append(CSV + getStringToDblQuote(pkozaShumoku))				// 種目
			.append(CSV + getStringToDblQuote(JKKStringConverter.convertFullMark(pkozaNo)))	// 口座番号
			.append(CSV + getStringToDblQuote(eanBarcode))					// EANバーコード
			.append(CSV + getStringToDblQuote(eanMonth))					// コンビニ支払期限月
			.append(CSV + getStringToDblQuote(eanDay))						// コンビニ支払期限日
			.append(CSV + getStringToDblQuote(tax))							// 内消費税
			.append(CSV + getStringToDblQuote(shInsHrtkMask))				// 収入印紙貼付欄マスク
			.append(System.getProperty(LINE_SEP));
		}
		return sb.toString().getBytes("UTF-8");
	}
	// ANK-3838-00-00 ADD END

	/**
	 * 通信サービス料金口座振替のお知らせ兼領収証情報をCSV形式のバイナリデータに変換する。
	 * @param param
	 * @param chohyoKbn
	 * @param bothDispMap 内訳両出力マップ
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private byte[] makeCSVDataTushinSvcPrcKoza(IRequestParameterReadWrite param, String chohyoKbn, HashMap<String, String> bothDispMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		// 業務パラメータ管理情報取得
		HashMap<String, String> workParamMap = getWorkParamKnri(param);

// 2014.06.04 OM-2014-0001921 add start
		// 通常文字サイズ か 小さい文字サイズ かのフラグ
		HashMap<String, String> editFlgMap = new HashMap<String, String>();
//2014.06.04 OM-2014-0001921 add end
		
		// 送付先
// 2014.06.04 OM-2014-0001921 mod start
//		ArrayList<String> addressList = editSohusaki(parentMapCC);
		ArrayList<String> addressList = editSohusaki(parentMapCC, editFlgMap);
// 2014.06.04 OM-2014-0001921 mod end
		
// 2014.06.04 OM-2014-0001921 add start
		// 住所リストから更新用住所配列を取得
		String[] strAddress1 = getAddressArray(addressList.get(0), editFlgMap);
		String[] strAddress2 = getAddressArray(addressList.get(1), editFlgMap);
		String[] strAddress3 = getAddressArray(addressList.get(2), editFlgMap);
		String[] strAddress4 = getAddressArray(addressList.get(3), editFlgMap);
//2014.06.04 OM-2014-0001921 add end

		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);

		// カスタマバーコード
		String customerBarCd = editOutputCustomerBarCd(parentMapCC);
		
		// 発行番号
		String hakkoNum = editHakkoNo(parentMapCC);

		// 発行日←オンライン運用日付
		String hakkoYmd = JCCBPCommon.getOpeDate(null);
		String hakkoYear = editYmd(hakkoYmd, DATE_KBN_YEAR);
		String hakkoMonth = editYmd(hakkoYmd, DATE_KBN_MON);
		String hakkoDay = editYmd(hakkoYmd, DATE_KBN_DAY);

		// ご請求年月
		String seikyYm = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM));
		String seikyYear = editYmd(seikyYm, DATE_KBN_YEAR);
		String seikyMonth = editZeroSpace(editYmd(seikyYm, DATE_KBN_MON));

		// 振替日
		String hurikaeYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0501B020_EVENT_YMD));
		String hurikaeYear = editYmd(hurikaeYmd, DATE_KBN_YEAR);
		String hurikaeMonth = editZeroSpace(editYmd(hurikaeYmd, DATE_KBN_MON));
		String hurikaeDay = editZeroSpace(editYmd(hurikaeYmd, DATE_KBN_DAY));

		// 金融機関名
		String bankNm = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_KOFURI_BANK_NM);
		
		// 金融機関支店名
		String bankShitenNm = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_KOFURI_BANK_SHITEN_NM);
		
		// 預金種目コード名称
		String yknShmkNm = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_KOFURI_YOKIN_SHUMOKU_CD_NM);
		
		// 口座番号
		String kozaNo = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_KOFURI_KOZA_NO);
		
		// 口座番号マスク化
		kozaNo = JPCUtilCommon.editCharStrMask(kozaNo, JACStrConst.ASTERISK, kozaNo.length() - 2, 3);

		// OM-2021-0000584 ADD START
		// 金融機関コード
		String bankCd = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_KOFURI_BANK_CD);
		
		// 通帳番号
		String tsuchoNo = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_KOFURI_TSUCHO_NO);
		
		if (tsuchoNo != null && !"".equals(tsuchoNo))
		{
			// 通帳番号マスク化
			tsuchoNo = tsuchoNo.substring(0,7);
			tsuchoNo = JPCUtilCommon.editCharStrMask(tsuchoNo, JACStrConst.ASTERISK, tsuchoNo.length() - 2, 3);
		}
		// OM-2021-0000584 ADD END
		
		// 前月振替日
		String zenHurikaeYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0501B020_ZEN_EVENT_YMD));
// ANK-4415-00-00 ADD START
		if(!JKKStringUtil.isNullBlank((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0111B010_PAY_YMD)))
		{
			zenHurikaeYmd = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0111B010_PAY_YMD);
		}
// ANK-4415-00-00 ADD END
		String zenHurikaeYear = editYmd(zenHurikaeYmd, DATE_KBN_YEAR);
		String zenHurikaeMonth = editZeroSpace(editYmd(zenHurikaeYmd, DATE_KBN_MON));
		String zenHurikaeDay = editZeroSpace(editYmd(zenHurikaeYmd, DATE_KBN_DAY));

		// 口座振替領収書のみの場合は当月の振替日を設定
		if (LIST_KBN_KOZA_RCPT.equals(chohyoKbn))
		{
			zenHurikaeYmd = hurikaeYmd;
			zenHurikaeYear = hurikaeYear;
			zenHurikaeMonth = hurikaeMonth;
			zenHurikaeDay = hurikaeDay;
		}
		
		// 領収額出力有無
		String receipAmntOputUm = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_RECEIPT_AMNT_OUTPUT_UM);
		
		// うち消費税
		String tax = new String();

		// 前月請求年月
		String zenSeikyYear = new String();
		String zenSeikyMon = new String();

		// 前月金融機関名
		String zenBankNm = new String();
		
		// 前月金融機関支店名
		String zenBankShitenNm = new String();
		
		// 前月預金種目コード名称
		String zenYknShmkNm = new String();
		
		// 前月口座番号
		String zenKozaNo = new String();

		// 領収金額
		String receipt = new String();

		// 前月領収が存在しない(receipAmntOputUm == null)、または
		// 領収額出力有無が「0(無)」の場合は、領収書情報の金融機関情報マスク化
		if (receipAmntOputUm == null || JACStrConst.RECEIPT_AMNT_OUTPUT_UM_NON.equals(receipAmntOputUm))
		{
			receipt = MASK_HN_15;
			tax = MASK_HN_15;
			zenHurikaeYear = MASK_4;
			zenHurikaeMonth = MASK_HN_2;
			zenHurikaeDay = MASK_HN_2;
			zenSeikyYear = MASK_4;
			zenSeikyMon = MASK_HN_2;
			zenBankNm = MASK_ZN_15;
			zenBankShitenNm = MASK_ZN_15;
			zenYknShmkNm = MASK_ZN_2;
			zenKozaNo = MASK_7;
		}
		else
		{
			// 領収金額
			receipt = JPCUtilCommon.formatNumber((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_RECEIPT));

			// 合算フラグ(発行元)
			String gsanFlg = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_GSAN_SEIKY_FLG);
			// 前受充当金額フラグ
			String maeukJutoFlg = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_MAEUKE_JUTO_FLG);

			// 合算フラグまたは前受充当金額フラグが1の場合、うち消費税をマスク化する
			if ("1".equals(gsanFlg) || "1".equals(maeukJutoFlg))
			{
				tax = MASK_HN_15;
			}
			else
			{
				// IT1-2023-0000051 MOD START
//				tax = JPCUtilCommon.formatNumber((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_TAX));
				String taxEdit = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_TAX);
				if (taxEdit.length() > 0 && Long.parseLong(taxEdit) < 0)
				{
					// うち消費税が0未満の場合、うち消費税をマスク化する
					tax = MASK_HN_15;
				}
				else
				{
					tax = JPCUtilCommon.formatNumber(taxEdit);
				}
				// IT1-2023-0000051 MOD END
			}

			// 前月請求年月
			String zenSeikyYm = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_ZEN_SEIKY_YM));
			zenSeikyYear = editYmd(zenSeikyYm, DATE_KBN_YEAR);
			zenSeikyMon = editZeroSpace(editYmd(zenSeikyYm, DATE_KBN_MON));

			// 前月金融機関名
			zenBankNm = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_BANK_NM);
			
			// 前月金融機関支店名
			zenBankShitenNm = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_BANK_SHITEN_NM);
			
			// 前月預金種目コード名称
			zenYknShmkNm = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_YOKIN_SHUMOKU_NM);
			
			// 前月口座番号
			zenKozaNo = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_KOZA_NO);
			zenKozaNo = JPCUtilCommon.editCharStrMask(zenKozaNo, JACStrConst.ASTERISK, zenKozaNo.length() - 2, 3);
		}
		
		// OM-2021-0000584 ADD START
		// 前月金融機関コード
		String zenBankCd = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_BANK_CD);
		
		// 前月通帳番号
		String zenTsuchoNo = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_TSUCHO_NO);
		
		if (zenTsuchoNo != null && !"".equals(zenTsuchoNo))
		{
			// 前月通帳番号マスク化
			zenTsuchoNo = zenTsuchoNo.substring(0,7);
			zenTsuchoNo = JPCUtilCommon.editCharStrMask(zenTsuchoNo, JACStrConst.ASTERISK, zenTsuchoNo.length() - 2, 3);
		}
		// OM-2021-0000584 ADD END

		// OM-2015-0001709 MOD START
//		// 請求抑止フラグが"1"の場合、領収書情報･次回口座振替情報マスク化
//		String yoksiFlg = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YOKSI_FLG);
		
		// 請求抑止フラグ（口座番号表示抑止）
		String yoksiFlg = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YOKSI_FLG_KOZA);
		
		// Nullの場合、"0"を設定
		if (JCRUtilCommon.isNull(yoksiFlg))
		{
			yoksiFlg = JACStrConst.YOKSI_FLG_NASHI;
		}
		
		// 請求抑止フラグ（口座番号表示抑止）が"1"の場合、領収書情報･次回口座振替情報マスク化
		// OM-2015-0001709 MOD END
		if(yoksiFlg.equals(JACStrConst.YOKSI_FLG_ARI))
		{
			zenBankNm = MASK_ZN_15;
			zenBankShitenNm = MASK_ZN_15;
			zenYknShmkNm = MASK_ZN_2;
			zenKozaNo = MASK_7;
			bankNm = MASK_ZN_15;
			bankShitenNm = MASK_ZN_15;
			yknShmkNm = MASK_ZN_2;
			kozaNo = MASK_7;
		}

		// 当月の請求金額
		long seikyAmnt = Long.parseLong((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT));
		// 領収金額
		long receiptAmt = 0L;
		if (parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_RECEIPT) != null) {
			receiptAmt = Long.parseLong((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051B040_RECEIPT));
		}

		// 印紙税対象額を「領収日（前月振替日）」を基準日として取得する
		long inshiTaxTgAmnt = Long.valueOf(JCHStampDutyUtil.getTaxableAmount(JACStrConst.CALLER_SCREEN, null, zenHurikaeYmd));
		
		// 収入印紙貼付欄マスク
		String shInsHrtkMask  = JACStrConst.KARA_MOJI;
		
		if(receiptAmt < inshiTaxTgAmnt)
		{
			// 印紙税対象ではない
			shInsHrtkMask = SN_INS_HRTK_MASK_AST;
		}
		
		ArrayList childList = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List");
		StringBuffer sb = new StringBuffer();

		// うち消費税を取得
		String nextTax = getZeiAmnt(param, LIST_KBN_KOZA);

		// 明細行形成
		for(int i = 0; i < childList.size(); i++) 
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);

			// 金額
			String strAmnt = new String();
			// 金額内訳
			String strUwAmnt = new String();
			// 金額表示カラム数
			String amntDspColumCnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT);

			// 料金グループコード
			String prcGrpCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
			// 料金コースコード
			String pcrsCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
			// 料金サービスコード
			String prcSvcCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
			// 料金項目コード

			String prcKmkCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
			//mineo単独の場合
			boolean isMineoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MINEO_TANDOKU);

//ANK-4595-01-00　ADD START
			//eo電気単独の場合
			boolean isElectTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.ELEC_TANDOKU);
			//マンションオーナーの場合
			boolean isMtonTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MTON_TANDOKU);
//ANK-4595-01-00　ADD END
//ANK-4427-00-00 ADD START
			//NTT卸単独の場合
			boolean isNttoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.NTTO_TANDOKU);
//ANK-4427-00-00 ADD END
			// 請求内訳両出力判定キー
			StringBuilder prcKmkKey = new StringBuilder();
			prcKmkKey.append(prcGrpCd).append(pcrsCd).append(prcSvcCd).append(prcKmkCd);

			// 料金項目コードが業務機能識別コード(請求内訳両出力)に存在する場合、金額、金額内訳両方に出力する
			if (bothDispMap.containsKey(prcKmkKey.toString()))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_ID_NO_SUM))
			{
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else
			{
				// 金額
				strAmnt = new String();
				
				// 金額内訳
				strUwAmnt = new String();
			}

			sb.append(getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD)))							// 郵便番号
// 2014.06.04 OM-2014-0001921 mod start
//			.append(CSV + getStringToDblQuote((String)addressList.get(0)))			// 送付住所1
//			.append(CSV + getStringToDblQuote((String)addressList.get(1)))			// 送付住所2
//			.append(CSV + getStringToDblQuote((String)addressList.get(2)))			// 送付住所3
//			.append(CSV + getStringToDblQuote((String)addressList.get(3)))			// 送付住所4
			.append(CSV + getStringToDblQuote(strAddress1[0]))		// 送付住所1
			.append(CSV + getStringToDblQuote(strAddress2[0]))		// 送付住所2
			.append(CSV + getStringToDblQuote(strAddress3[0]))		// 送付住所3
			.append(CSV + getStringToDblQuote(strAddress4[0]))		// 送付住所4
// 2014.06.04 OM-2014-0001921 mod end
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(0)))				// 送付先名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))				// 送付先部課名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))				// 送付先担当者名

			.append(CSV + getStringToDblQuote(customerBarCd))		// カスタマーバーコード
			.append(CSV + getStringToDblQuote(hakkoNum))			// 発行番号
			.append(CSV + getStringToDblQuote(""))					// 請求書印刷番号１
			.append(CSV + getStringToDblQuote(""))					// 請求書印刷番号２
			.append(CSV + getStringToDblQuote(hakkoYear))			// 発行年月日（年）
			.append(CSV + getStringToDblQuote(hakkoMonth))			// 発行年月日（月）
			.append(CSV + getStringToDblQuote(hakkoDay))			// 発行年月日（日）
			.append(CSV + getStringToDblQuote(receipt))				// 領収金額
			.append(CSV + getStringToDblQuote(tax))					// うち消費税
			.append(CSV + getStringToDblQuote(zenHurikaeYear))		// 振替日（年）
			.append(CSV + getStringToDblQuote(zenHurikaeMonth))		// 振替日（月）
			.append(CSV + getStringToDblQuote(zenHurikaeDay))		// 振替日（日）
			.append(CSV + getStringToDblQuote(zenSeikyYear))		// 請求月（年）
			.append(CSV + getStringToDblQuote(zenSeikyMon))			// 請求月（月）
			
			//OM-2021-0000584 DEL START
			//.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(zenBankNm, CHOHYO_OUT_BANK_NM_LENGTH)))				// 金融機関名
			//.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(zenBankShitenNm, CHOHYO_OUT_BANK_SHITEN_NM_LENGTH)))	// 金融機関支店名
			//.append(CSV + getStringToDblQuote(zenYknShmkNm))		// 預金項目名
			//.append(CSV + getStringToDblQuote(zenKozaNo))			// 口座番号
			//.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)))				// お客様番号
			//OM-2021-0000584 DEL END
			
			//OM-2021-0000584 ADD START
			.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(zenBankNm, CHOHYO_OUT_BANK_NM_LENGTH)));				// 金融機関名
			
			// 前月領収が存在しない(receipAmntOputUm == null)、または、領収額出力有無が「0(無)」の場合
			if (receipAmntOputUm == null || JACStrConst.RECEIPT_AMNT_OUTPUT_UM_NON.equals(receipAmntOputUm))
			{
				sb.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(zenBankShitenNm, CHOHYO_OUT_BANK_SHITEN_NM_LENGTH)))	// 金融機関支店名
				.append(CSV + getStringToDblQuote(zenYknShmkNm))		// 預金項目名
				.append(CSV + getStringToDblQuote(zenKozaNo));			// 口座番号
			}
			// 請求抑止フラグ（口座番号表示抑止）が"1"の場合
			else if (JACStrConst.YOKSI_FLG_ARI.equals(yoksiFlg))
			{
				sb.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(zenBankShitenNm, CHOHYO_OUT_BANK_SHITEN_NM_LENGTH)))	// 金融機関支店名
				.append(CSV + getStringToDblQuote(zenYknShmkNm))		// 預金項目名
				.append(CSV + getStringToDblQuote(zenKozaNo));			// 口座番号
			}
			// 前月金融機関コードが"9900"の場合
			else if (YUCHO_YUBIN_BANK_CD.equals(zenBankCd))
			{
				sb.append(CSV + getStringToDblQuote(""))			// 金融機関支店名
				.append(CSV + getStringToDblQuote(""))				// 預金項目名
				.append(CSV + getStringToDblQuote(zenTsuchoNo));	// 口座番号
			}
			// 前月領収が存在する、かつ、領収額出力有無が「0(無)」以外、かつ
			// 請求抑止フラグ（口座番号表示抑止）が"1"以外、かつ、前月金融機関コードが"9900"以外の場合
			else
			{
				sb.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(zenBankShitenNm, CHOHYO_OUT_BANK_SHITEN_NM_LENGTH)))	// 金融機関支店名
				.append(CSV + getStringToDblQuote(zenYknShmkNm))		// 預金項目名
				.append(CSV + getStringToDblQuote(zenKozaNo));			// 口座番号
			}
			sb.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)))				// お客様番号
			//OM-2021-0000584 ADD END

			.append(CSV + getStringToDblQuote(""))					// お知らせ１
			.append(CSV + getStringToDblQuote(""))					// お知らせ２
			.append(CSV + getStringToDblQuote(""))					// お知らせ３
			.append(CSV + getStringToDblQuote(""))					// お知らせ４
			.append(CSV + getStringToDblQuote(""))					// お知らせ５
			.append(CSV + getStringToDblQuote(""))					// お知らせ６
			.append(CSV + getStringToDblQuote(""))					// お知らせ７
			.append(CSV + getStringToDblQuote(""));					// お知らせ８

//ANK-4595-01-00 MOD START
//			if(!isMineoTandoku)
			//mineo単独以外　かつ　eo電気単独以外　かつ　マンションオーナー以外の場合
//ANK-4427-00-00 MOD START
			//if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku)
			////mineo単独以外　かつ　電気単独以外　かつ　マンションオーナー以外　且つ　NTT卸単独以外の場合
			if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku && !isNttoTandoku)
//ANK-4427-00-00 MOD END	
//ANK-4595-01-00 MOD END
			{
				sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))			// お問合せ先１
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))				// お問合せ先２
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))				// お問合せ先３
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD04)))				// お問合せ先４
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))				// お問合せ先５
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));				// お問合せ先６
			}
			else
			{
//ANK-4595-01-00 ADD START
				//mineo単独の場合
				if(isMineoTandoku && !isElectTandoku)
				{
//ANK-4595-01-00 ADD END
					sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV01)))			// お問合せ先１
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV02)))				// お問合せ先２
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV03)))				// お問合せ先３
//ANK-4595-01-00 MOD START
//					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV04)))				// お問合せ先４
//					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)))				// お問合せ先５
//					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV06)));				// お問合せ先６
//IT2-2024-0000014 ADD START
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV04)))				// お問合せ先４
//IT2-2024-0000014 ADD END
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)));				// お問合せ先5
					 
					if (tiawaseKirikaeDay.compareTo(hakkoYmd) > 0) 
					{ // 運用日が2022/12/11 より前の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV06)));			// お問合せ先５（旧）
					}
					else 
					{ // 運用日が2022/12/11 以降の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV07)));			// お問合せ先５（新）
					}
//ANK-4595-01-00 MOD END
					//ANK-4595-01-00 ADD START
					
				}
				else
				{
					//eo電気単独の場合
					if(isElectTandoku && !isMineoTandoku)
					{
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL01)))			// お問合せ先１
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL02)))				// お問合せ先２
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL03)))				// お問合せ先３
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL04)))				// お問合せ先４
//IT2-2024-0000013 MOD START
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)))				// お問合せ先５
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL06)));				// お問合せ先６
//IT2-2024-0000014 MOD START
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)));				// お問合せ先５
//IT2-2024-0000013 MOD END
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)))				// お問合せ先５
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL06)));				// お問合せ先６
//IT2-2024-0000014 MOD END
					}
					else
					{
						//マンションオーナーの場合
						if(isMtonTandoku){
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT01)))			// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT02)))				// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT03)))				// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT04)))				// お問合せ先４
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05)))				// お問合せ先５
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06)));				// お問合せ先６
						}
						//mieno単独であり電気単独である場合
						if(isMineoTandoku && isElectTandoku)
						{
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))			// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))				// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))				// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD04)))				// お問合せ先４
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))				// お問合せ先５
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));				// お問合せ先６
						}
	//ANK-4427-00-00 ADD START
						//NTT卸単独の場合
						if(isNttoTandoku){
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT02)))					// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT03)))					// お問合せ先３
//IT2-2024-0000082 DEL START
//							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT04)))					// お問合せ先４
//IT2-2024-0000082 DEL END							
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT05)))					// お問合せ先５
//IT2-2024-0000082 MOD START
							//.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT06)));				// お問合せ先６	
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT06)))				    // お問合せ先６	
//IT2-2024-0000082 MOD END							
//IT2-2024-0000082 ADD START
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT04)));				// お問合せ先４
//IT2-2024-0000082 ADD END	
						}
	//ANK-4427-00-00 ADD END
					}	
				}
//ANK-4595-01-00 ADD END
			}

			if (LIST_KBN_KOZA.equals(chohyoKbn))
			{
// ANK-4175-00-00 DEL START
//				// 当月の請求額が0の場合、次回口座振替情報をマスク化
//				// (請求額がマイナスの金額になる事はない為、請求額が0円の場合にマスク化する)
//				if (seikyAmnt == 0L)
//				{
//					sb.append(CSV + getStringToDblQuote(MASK_HN_15))	// 次回振替額
//					.append(CSV + getStringToDblQuote(MASK_HN_15))		// 次回うち消費税
//					.append(CSV + getStringToDblQuote(MASK_4))			// 次回振替日（年）
//					.append(CSV + getStringToDblQuote(MASK_HN_2))	    // 次回振替日（月）
//					.append(CSV + getStringToDblQuote(MASK_HN_2))		// 次回振替日（日）
//					.append(CSV + getStringToDblQuote(MASK_4))			// 次回請求月（年）
//					.append(CSV + getStringToDblQuote(MASK_HN_2))		// 次回請求月（月）
//					.append(CSV + getStringToDblQuote(MASK_ZN_15))		// 次回金融機関名
//					.append(CSV + getStringToDblQuote(MASK_ZN_15))		// 次回金融機関支店名
//					.append(CSV + getStringToDblQuote(MASK_ZN_2))		// 次回預金項目名
//					.append(CSV + getStringToDblQuote(MASK_7));			// 次回口座番号
//				}
//				else
//				{
// ANK-4175-00-00 DEL END
					// 次回振替額
					sb.append(CSV + getStringToDblQuote(JPCUtilCommon.formatNumber((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT))))
					.append(CSV + getStringToDblQuote(nextTax))			// 次回うち消費税
					.append(CSV + getStringToDblQuote(hurikaeYear))		// 次回振替日（年）
					.append(CSV + getStringToDblQuote(hurikaeMonth))	// 次回振替日（月）
					.append(CSV + getStringToDblQuote(hurikaeDay))		// 次回振替日（日）
					.append(CSV + getStringToDblQuote(seikyYear))		// 次回請求月（年）
					.append(CSV + getStringToDblQuote(seikyMonth))		// 次回請求月（月）
					
					//OM-2021-0000584 DEL START
					//.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(bankNm, CHOHYO_OUT_BANK_NM_LENGTH)))				// 次回金融機関名
					//.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(bankShitenNm, CHOHYO_OUT_BANK_SHITEN_NM_LENGTH)))	// 次回金融機関支店名
					//.append(CSV + getStringToDblQuote(yknShmkNm))		// 次回預金項目名
					//.append(CSV + getStringToDblQuote(kozaNo));			// 次回口座番号
					//OM-2021-0000584 DEL END
					
					//OM-2021-0000584 ADD START
					.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(bankNm, CHOHYO_OUT_BANK_NM_LENGTH)));				// 次回金融機関名
					
					// 請求抑止フラグ（口座番号表示抑止）が"1"の場合
					if (JACStrConst.YOKSI_FLG_ARI.equals(yoksiFlg))
					{
						sb.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(bankShitenNm, CHOHYO_OUT_BANK_SHITEN_NM_LENGTH)))	// 次回金融機関支店名
						.append(CSV + getStringToDblQuote(yknShmkNm))		// 次回預金項目名
						.append(CSV + getStringToDblQuote(kozaNo));			// 次回口座番号
					}
					// 金融機関コードが"9900"の場合
					else if (YUCHO_YUBIN_BANK_CD.equals(bankCd))
					{
						sb.append(CSV + getStringToDblQuote(""))			// 次回金融機関支店名
						.append(CSV + getStringToDblQuote(""))				// 次回預金項目名
						.append(CSV + getStringToDblQuote(tsuchoNo));		// 次回口座番号
					}
					// 請求抑止フラグ（口座番号表示抑止）が"1"以外、かつ、金融機関コードが"9900"以外の場合
					else
					{
						sb.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(bankShitenNm, CHOHYO_OUT_BANK_SHITEN_NM_LENGTH)))	// 次回金融機関支店名
						.append(CSV + getStringToDblQuote(yknShmkNm))		// 次回預金項目名
						.append(CSV + getStringToDblQuote(kozaNo));			// 次回口座番号
					}
					//OM-2021-0000584 ADD END
// ANK-4175-00-00 DEL START
//				}
// ANK-4175-00-00 DEL END

				sb.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM)))								// 料金内訳
				.append(CSV + getStringToDblQuote(strAmnt))			// 金額
				.append(CSV + getStringToDblQuote(strUwAmnt))		// 金額内訳
				.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT)))						// 金額合計
				.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT)));					// 内訳額合計
			}
			else if (LIST_KBN_KOZA_RCPT.equals(chohyoKbn))
			{
				sb.append(CSV + getStringToDblQuote(MASK_HN_15))	// 次回振替額
				.append(CSV + getStringToDblQuote(MASK_HN_15))		// 次回うち消費税
				.append(CSV + getStringToDblQuote(MASK_4))			// 次回振替日（年）
				.append(CSV + getStringToDblQuote(MASK_HN_2))	    // 次回振替日（月）
				.append(CSV + getStringToDblQuote(MASK_HN_2))		// 次回振替日（日）
// ANK-4175-00-00 MOD START
//				.append(CSV + getStringToDblQuote(MASK_4))			// 次回請求月（年）
//				.append(CSV + getStringToDblQuote(MASK_HN_2))		// 次回請求月（月）
				.append(CSV + getStringToDblQuote(seikyYear))		// 次回請求月（年）
				.append(CSV + getStringToDblQuote(seikyMonth))		// 次回請求月（月）
// ANK-4175-00-00 MOD END
				.append(CSV + getStringToDblQuote(MASK_ZN_15))		// 次回金融機関名
				.append(CSV + getStringToDblQuote(MASK_ZN_15))		// 次回金融機関支店名
				.append(CSV + getStringToDblQuote(MASK_ZN_2))		// 次回預金項目名
				.append(CSV + getStringToDblQuote(MASK_7))			// 次回口座番号

				.append(CSV + getStringToDblQuote(""))				// 料金内訳
				.append(CSV + getStringToDblQuote(""))				// 金額
				.append(CSV + getStringToDblQuote(""))				// 金額内訳
				.append(CSV + getStringToDblQuote(""))				// 金額合計
				.append(CSV + getStringToDblQuote(""));				// 内訳額合計
			}

			sb.append(CSV + getStringToDblQuote(shInsHrtkMask))						// 収入印紙貼付欄マスク

// 2014.06.04 OM-2014-0001921 add start
			.append(CSV + getStringToDblQuote(strAddress1[1]))			// 送付住所1-2
			.append(CSV + getStringToDblQuote(strAddress2[1]))			// 送付住所2-2
			.append(CSV + getStringToDblQuote(strAddress3[1]))			// 送付住所3-2
			.append(CSV + getStringToDblQuote(strAddress4[1]))			// 送付住所4-2
// 2014.06.04 OM-2014-0001921 add end

			.append(System.getProperty(LINE_SEP));
		}
		
		//UTF-8のバイト配列に変換して返す
		return sb.toString().getBytes("UTF-8");
	}

	/**
	 * 通信サービス料金お知らせ情報をCSV形式のバイナリデータに変換する。
	 * @param param
	 * @param bothDispMap 内訳両出力マップ
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private byte[] makeCSVDataTushinSvcPrcInfo(IRequestParameterReadWrite param, HashMap<String, String> bothDispMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		// 業務パラメータ管理情報取得
		HashMap<String, String> workParamMap = getWorkParamKnri(param);

// 2014.06.04 OM-2014-0001921 add start
		// 通常文字サイズ か 小さい文字サイズ かのフラグ
		HashMap<String, String> editFlgMap = new HashMap<String, String>();
//2014.06.04 OM-2014-0001921 add end
		
		// 送付先
// 2014.06.04 OM-2014-0001921 mod start
//		ArrayList<String> addressList = editSohusaki(parentMapCC);
		ArrayList<String> addressList = editSohusaki(parentMapCC, editFlgMap);
// 2014.06.04 OM-2014-0001921 mod end

// 2014.06.04 OM-2014-0001921 add start
		// 住所リストから更新用住所配列を取得
		String[] strAddress1 = getAddressArray(addressList.get(0), editFlgMap);
		String[] strAddress2 = getAddressArray(addressList.get(1), editFlgMap);
		String[] strAddress3 = getAddressArray(addressList.get(2), editFlgMap);
		String[] strAddress4 = getAddressArray(addressList.get(3), editFlgMap);
//2014.06.04 OM-2014-0001921 add end

		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);

		// カスタマバーコード
		String customerBarCd = editOutputCustomerBarCd(parentMapCC);
		
		// 発行番号
		String hakkoNum = editHakkoNo(parentMapCC);

		// 発行日←オンライン運用日付
		String hakkoYmd = JCCBPCommon.getOpeDate(null);
		String hakkoYear = editYmd(hakkoYmd, DATE_KBN_YEAR);
		String hakkoMonth = editYmd(hakkoYmd, DATE_KBN_MON);
		String hakkoDay = editYmd(hakkoYmd, DATE_KBN_DAY);

		// ご利用年月月
		String seikyYm = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM)).trim();
		String seikyYear = editYmd(seikyYm, DATE_KBN_YEAR);
		String seikyMonth = editYmd(seikyYm, DATE_KBN_MON);

		ArrayList childList = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List");
		StringBuffer sb = new StringBuffer();

		// 当月の請求金額
		long seikyAmnt = Long.parseLong((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT));

		// うち消費税を取得
		String tax = getZeiAmnt(param, LIST_KBN_CREZ);
		
		//mineo単独の場合
		boolean isMineoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MINEO_TANDOKU);

//ANK-4595-01-00 ADD START
		//eo電気単独の場合
		boolean isElectTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.ELEC_TANDOKU);
		//マンションオーナーの場合
		boolean isMtonTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.MTON_TANDOKU);
//ANK-4595-01-00 ADD END
//ANK-4427-00-00 ADD START
		//NTT卸単独の場合
		boolean isNttoTandoku =  (Boolean)parentMapCC.get(JCHTushinSvcConstCC.NTTO_TANDOKU);
//ANK-4427-00-00 ADD END
		// 明細行形成
		for(int i = 0; i < childList.size(); i++) 
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);

			// 金額
			String strAmnt = new String();
			// 金額内訳
			String strUwAmnt = new String();
			// 金額表示カラム数
			String amntDspColumCnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT);

			// 料金グループコード
			String prcGrpCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
			// 料金コースコード
			String pcrsCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
			// 料金サービスコード
			String prcSvcCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
			// 料金項目コード
			String prcKmkCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);

			// 請求内訳両出力判定キー
			StringBuilder prcKmkKey = new StringBuilder();
			prcKmkKey.append(prcGrpCd).append(pcrsCd).append(prcSvcCd).append(prcKmkCd);

			// 料金項目コードが業務機能識別コード(請求内訳両出力)に存在する場合、金額、金額内訳両方に出力する
			if (bothDispMap.containsKey(prcKmkKey.toString()))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT))
			{
				// 金額
				strAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_ID_NO_SUM))
			{
				// 金額内訳
				strUwAmnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
			else
			{
				// 金額
				strAmnt = new String();
				// 金額内訳
				strUwAmnt = new String();
			}

			// クレジット会社名
			String crecaCompNm = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_CRECARD_CRECARD_COMP_NM);

			sb.append(getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD)))							// 郵便番号
// 2014.06.04 OM-2014-0001921 mod start
//			.append(CSV + getStringToDblQuote((String)addressList.get(0)))				// 送付住所1
//			.append(CSV + getStringToDblQuote((String)addressList.get(1)))				// 送付住所2
//			.append(CSV + getStringToDblQuote((String)addressList.get(2)))				// 送付住所3
//			.append(CSV + getStringToDblQuote((String)addressList.get(3)))				// 送付住所4
			.append(CSV + getStringToDblQuote(strAddress1[0]))		// 送付住所1
			.append(CSV + getStringToDblQuote(strAddress2[0]))		// 送付住所2
			.append(CSV + getStringToDblQuote(strAddress3[0]))		// 送付住所3
			.append(CSV + getStringToDblQuote(strAddress4[0]))		// 送付住所4
// 2014.06.04 OM-2014-0001921 mod end
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(0)))				// 送付先名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))				// 送付先部課名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))				// 送付先担当者名

			.append(CSV + getStringToDblQuote(customerBarCd))	// カスタマーバーコード
			.append(CSV + getStringToDblQuote(hakkoNum))		// 発行番号
			.append(CSV + getStringToDblQuote(""))				// 請求書印刷番号１
			.append(CSV + getStringToDblQuote(""))				// 請求書印刷番号２
			.append(CSV + getStringToDblQuote(""))				// お知らせ１
			.append(CSV + getStringToDblQuote(""))				// お知らせ２
			.append(CSV + getStringToDblQuote(""))				// お知らせ３
			.append(CSV + getStringToDblQuote(""))				// お知らせ４
			.append(CSV + getStringToDblQuote(""))				// お知らせ５
			.append(CSV + getStringToDblQuote(""))				// お知らせ６
			.append(CSV + getStringToDblQuote(""))				// お知らせ７
			.append(CSV + getStringToDblQuote(""));				// お知らせ８

//ANK-4595-01-00 MOD START
//			if(!isMineoTandoku)
			//mineo単独以外　かつ　eo電気単独以外　かつ　マンションオーナー以外の場合
//ANK-4427-00-00 MOD START
			//if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku)
			////mineo単独以外　かつ　電気単独以外　かつ　マンションオーナー以外　且つ　NTT卸単独以外の場合
			if(!isMineoTandoku && !isElectTandoku && !isMtonTandoku && !isNttoTandoku)
//ANK-4427-00-00 MOD END
//ANK-4595-01-00 MOD END
			{
				sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))			// お問合せ先１
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))				// お問合せ先２
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))				// お問合せ先３
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD04)))				// お問合せ先４
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))				// お問合せ先５
				.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));				// お問合せ先６
			}
			else
			{
//ANK-4595-01-00 ADD START
				//mineo単独の場合
				if(isMineoTandoku && !isElectTandoku)
				{
//ANK-4595-01-00 ADD END
					sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV01)))			// お問合せ先１
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV02)))				// お問合せ先２
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV03)))				// お問合せ先３
////ANK-4595-01-00 MOD START
//					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV04)))				// お問合せ先４
//					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)))				// お問合せ先５
//					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV06)));				// お問合せ先６
//IT2-2024-0000014 MOD START
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV04)))				// お問合せ先４
//IT2-2024-0000014 MOD END
					.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV05)));				// お問合せ先５
					if (tiawaseKirikaeDay.compareTo(hakkoYmd) > 0) 
					{ // 運用日が2022/12/11 より前の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV06)));				// お問合せ先６
					}
					else 
					{ // 運用日が2022/12/11 以降の場合
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MV07)));			// お問合せ先５（新）
					}
//ANK-4595-01-00 MOD END					
					
//ANK-4595-01-00 ADD START
				}
				else
				{
					//eo電気単独の場合
					if(isElectTandoku && !isMineoTandoku)
					{
						sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL01)))			// お問合せ先１
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL02)))				// お問合せ先２
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL03)))				// お問合せ先３
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL04)))				// お問合せ先４
//IT2-2024-0000013 MOD START
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)))				// お問合せ先５
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL06)));				// お問合せ先６
//IT2-2024-0000014 MOD START						
//						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)));				// お問合せ先５
//IT2-2024-0000013 MOD END
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL05)))				// お問合せ先５
						.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_EL06)));				// お問合せ先６
//IT2-2024-0000014 MOD END
					}
					else
					{
						//マンションオーナーの場合
						if(isMtonTandoku)
						{
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT01)))			// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT02)))				// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT03)))				// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT04)))				// お問合せ先４
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT05)))				// お問合せ先５
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MT06)));				// お問合せ先６
						}
						//mieno単独であり電気単独である場合
						if(isMineoTandoku && isElectTandoku )
						{
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD01)))			// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD02)))				// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD03)))				// お問合せ先３
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD04)))				// お問合せ先４
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD05)))				// お問合せ先５
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_MD06)));				// お問合せ先６
						}
	//ANK-4427-00-00 ADD START
						//NTT卸単独の場合
						if(isNttoTandoku){
							sb.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT01)))				// お問合せ先１
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT02)))					// お問合せ先２
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT03)))					// お問合せ先３
//IT2-2024-0000082 DEL START
//							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT04)))					// お問合せ先４
//IT2-2024-0000082 DEL END
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT05)))					// お問合せ先５
//IT2-2024-0000082 MOD START
							//.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT06)));				// お問合せ先６
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT06)))			    	// お問合せ先６
//IT2-2024-0000082 MOD END
//IT2-2024-0000082 ADD START
							.append(CSV + getStringToDblQuote(workParamMap.get(JACStrConst.WKPAR_CH_TOIAWASESK_NTT04)));				// お問合せ先４
//IT2-2024-0000082 ADD END
						}
	//ANK-4427-00-00 ADD END
					}
				}	
//ANK-4595-01-00 ADD END
			}
			sb.append(CSV + getStringToDblQuote(hakkoYear))		// 発行年月日（年）
			.append(CSV + getStringToDblQuote(hakkoMonth))		// 発行年月日（月）
			.append(CSV + getStringToDblQuote(hakkoDay));		// 発行年月日（日）

// ANK-4175-00-00 DEL START
//			// 当月のご請求金額が0円の場合、ご利用料金情報をマスク化する
//			if (seikyAmnt == 0)
//			{
//				sb.append(CSV + getStringToDblQuote(MASK_4))		// ご利用年月（年）
//				.append(CSV + getStringToDblQuote(MASK_HN_2))		// ご利用年月（月）
//				.append(CSV + getStringToDblQuote(MASK_HN_15))	// ご利用料金
//				.append(CSV + getStringToDblQuote(MASK_HN_15))	// うち消費税
//				.append(CSV + getStringToDblQuote(MASK_ZN_15));	// クレジット会社名
//			}
//			else
//			{
// ANK-4175-00-00 DEL END
				sb.append(CSV + getStringToDblQuote(editZeroSpace(seikyYear)))		// ご利用年月（年）
				.append(CSV + getStringToDblQuote(editZeroSpace(seikyMonth)))		// ご利用年月（月）
				.append(CSV + getStringToDblQuote(JPCUtilCommon.formatNumber((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT))))	// ご利用料金
				.append(CSV + getStringToDblQuote(tax))				// うち消費税
				.append(CSV + getStringToDblQuote(JACCommonUtil.editStrLength(crecaCompNm, CHOHYO_OUT_CRECA_COMP_NM_LENGTH)));				// クレジット会社名
// ANK-4175-00-00 DEL START
//			}
// ANK-4175-00-00 DEL END

			sb.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)))				// お客様番号

			// ご利用料金内訳
			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM)))								// 料金内訳
			.append(CSV + getStringToDblQuote(strAmnt))			// 金額
			.append(CSV + getStringToDblQuote(strUwAmnt))		// 内訳額
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT)))						// 金額合計
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_AMNT)))						// 内訳額合計

// 2014.06.04 OM-2014-0001921 add start
			.append(CSV + getStringToDblQuote(strAddress1[1]))			// 送付住所1-2
			.append(CSV + getStringToDblQuote(strAddress2[1]))			// 送付住所2-2
			.append(CSV + getStringToDblQuote(strAddress3[1]))			// 送付住所3-2
			.append(CSV + getStringToDblQuote(strAddress4[1]))			// 送付住所4-2
// 2014.06.04 OM-2014-0001921 add end
			
			.append(System.getProperty(LINE_SEP));
		}

		//UTF-8のバイト配列に変換して返す
		return sb.toString().getBytes("UTF-8");
	}

	/**
	 * 通信サービス料金内訳リスト情報をCSV形式のバイナリデータに変換する。
	 * @param param
	 * @param bothDispMap 内訳両出力マップ
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private byte[] makeCSVDataTushinSvcPrcUcwk(IRequestParameterReadWrite param, HashMap<String, String> bothDispMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		ArrayList childList = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List");
		int len = childList.size();

		// 料金項目抽出変換一覧明細を取得
		List<HashMap<String, Object>> msgList2 =
			(ArrayList<HashMap<String, Object>>)parentMapCC.get(COL_ECH0401B010LIST2);

		// 「請求内訳明細非表示」の料金項目コードを取得しマップに設定する（キーのみ使用）
		HashMap<String, String> nonDispMap = new HashMap<String, String>();
		for (HashMap<String, Object> msg : msgList2)
		{
			StringBuilder key = new StringBuilder();
			key.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD))
				.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD))
				.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD))
				.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD));

			nonDispMap.put(key.toString(), null);
		}

		StringBuffer sb = new StringBuffer();

		// フォーマット編集
		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);

		// 発行番号
		String hakkoNum = editHakkoNo(parentMapCC);

		// 請求年月
		String seikyYm = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM)).trim();

		String seikyYear = editYmd(seikyYm, DATE_KBN_YEAR);
		String seikyMonth = editYmd(seikyYm, DATE_KBN_MON);

		boolean kagami_bool = true;
		String temp_ctrl_flg = "";

		// 明細行形成
		for(int i = 0; i < len; i++) 
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);

			// 料金グループコード
			String prcGrpCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
			// 料金コースコード
			String pcrsCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
			// 料金サービスコード
			String prcSvcCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
			// 料金項目コード
			String prcKmkCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);

			// 請求内訳非表示判定キー
			StringBuilder prcKmkKey = new StringBuilder();
			prcKmkKey.append(prcGrpCd).append(pcrsCd).append(prcSvcCd).append(prcKmkCd);

			// 料金項目コードが業務機能識別コード(請求内訳明細非表示)に存在する場合、
			// 内訳明細として出力しない
			if (nonDispMap.containsKey(prcKmkKey.toString()))
			{
				continue;
			}

			temp_ctrl_flg = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_SVKEI_NO_DSP_CTRL_FLG);
			
			if(kagami_bool && (temp_ctrl_flg == null || "".equals(temp_ctrl_flg)))
			{
				kagami_bool = false;
				continue;
			}
			else if(kagami_bool)
			{
				continue;
			}

			// 内訳額
			String ucwkGak = new String();
			// 内訳額
			String zeiKbn = new String();
			// 金額内訳
			String kinUcwk = new String();

			// 金額表示カラム数
			String amntDspColumCnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT);
			// 金額編集パターンコード
			String amntHenshuPtnCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_HENSHU_PTN_CD);

			// 料金項目コードが業務機能識別コード(請求内訳両出力)に存在する場合、金額、金額内訳両方に出力する
			if (bothDispMap.containsKey(prcKmkKey.toString()))
			{
				ucwkGak = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				ucwkGak = editAmnt(ucwkGak, amntHenshuPtnCd);
				kinUcwk = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				kinUcwk = editAmnt(kinUcwk, amntHenshuPtnCd);
			}
			// 金額カラム数"0"の場合、金額・金額内訳共に未設定
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_ZERO))
			{
				ucwkGak = new String();
				kinUcwk = new String();
			}
			// 金額カラム数"1"の場合、金額に設定
			else if(amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT))
			{
				ucwkGak = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				ucwkGak = editAmnt(ucwkGak, amntHenshuPtnCd);
			}
			// 金額カラム数"2"の場合、金額内訳に設定
			else if(amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_TWO))
			{
				kinUcwk = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				kinUcwk = editAmnt(kinUcwk, amntHenshuPtnCd);
			}
			// 上記以外の場合、金額・金額内訳共に設定
			else
			{
				ucwkGak = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				ucwkGak = editAmnt(ucwkGak, amntHenshuPtnCd);
				kinUcwk = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				kinUcwk = editAmnt(kinUcwk, amntHenshuPtnCd);
			}

			if (null != msg.get(JCHTushinSvcConstCC.ECH0101B010_TAX_DIV_DSP_FLG)
					&& "1".equals((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_TAX_DIV_DSP_FLG)))
			{
				zeiKbn = "*";
			}
			else
			{
				zeiKbn = ""; 
			}

			// 利用期間
			String useKikan = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_KIKAN);
			
			if(JACStrConst.USE_PRD_DSP_CTRL_FLG_ON.equals((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_PRD_DSP_CTRL_FLG)))
			{
				/*---< #81816 MOD start >---*/
//				useKikan = JCHCommonFormatUtil.convRiyoKikan(useKikan);
				//料金グループコード　＝　"51"(ｍｉｎｅｏ)  かつ　利用終了年月日の年月　＜　請求年月の場合、空文字を設定
				if ((prcGrpCd != null && prcGrpCd.equals("51"))
						&& ((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_ENDYMD) != null && ((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_ENDYMD)).length() == 8)
						&& ((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_SEIKY_YM) != null && ((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_SEIKY_YM)).length() == 6)
						&& (((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_ENDYMD)).substring(0,6).compareTo((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_SEIKY_YM)) < 0)
					)
				{
					useKikan = JACStrConst.KARA_MOJI;
				}
				else
				{
					// 半角数字を全角に変換
					useKikan = JCHCommonFormatUtil.convRiyoKikan(useKikan);
				}
				/*---< #81816 MOD end >---*/
			}
			else
			{
				useKikan = JACStrConst.KARA_MOJI;
			}

			// 料金項目名称
			String strPrcKmkNm = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM);

			// 料金項目名称（すでに全角に変換済）が30文字を超える場合は切り捨てる
			if (strPrcKmkNm.length() > 30)
			{
				strPrcKmkNm = strPrcKmkNm.substring(0, 30);
			}

			// ANK-4401-00-00 ADD START
			// 追加タイトル
			String addTitle = new String();
			String prc_chg_flg = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_PRC_CHGE_FLG);

			// 料金変更フラグが「"1"：変更済」の場合、追加タイトルに"<修正>"を設定する
			if (JACStrConst.PRC_CHG_FLG.equals(prc_chg_flg))
			{
				addTitle = "<修正>";
			}
			else
			{
				addTitle = JACStrConst.KARA_MOJI;
			}
			
			// 適格請求書発行事業者登録番号
			String TkkkSksHakkoJigyoshaAddNo = (String)parentMapCC.get(JCHTushinSvcConstCC.EZM0311A010_SYS_PARAM_SETTE_VALUE_1);
			
			// 料金変更フラグが「"1"：変更済」の場合、追加タイトルに"<修正>"を設定する
			if (TkkkSksHakkoJigyoshaAddNo == null)
			{
				TkkkSksHakkoJigyoshaAddNo = JACStrConst.KARA_MOJI;
			}
			// ANK-4401-00-00 ADD END

			sb.append(getStringToDblQuote((String)sohusNmList.get(0)))					// 送付先名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))				// 送付先部課名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))				// 送付先担当者名
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)))		// お客様番号
			.append(CSV + getStringToDblQuote(hakkoNum))		// 発行番号
//			.append(CSV + nengo)			// 請求年月年号
			.append(CSV + getStringToDblQuote(seikyYear))		// 請求年月（年）
			.append(CSV + getStringToDblQuote(seikyMonth))		// 請求年月（月）

			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_OUT_SEIRI_NO)))					// NO
			.append(CSV + getStringToDblQuote(strPrcKmkNm))		// 料金内訳
			.append(CSV + getStringToDblQuote(zeiKbn))			// 税区分
			.append(CSV + getStringToDblQuote(ucwkGak))			// 内訳額
			.append(CSV + getStringToDblQuote(kinUcwk))			// 金額内訳
			.append(CSV + getStringToDblQuote(useKikan))		// 利用期間
			// ANK-4401-00-00 ADD START
			// IT1-2023-0000023 DEL START
//			.append(CSV + getStringToDblQuote(TkkkSksHakkoJigyoshaAddNo))		// 適格請求書発行事業者登録番号
			// IT1-2023-0000023 DEL END
			.append(CSV + getStringToDblQuote(addTitle))		// 追加タイトル
			// ANK-4401-00-00 ADD END
			// IT1-2023-0000023 ADD START
			.append(CSV + getStringToDblQuote(TkkkSksHakkoJigyoshaAddNo))		// 適格請求書発行事業者登録番号
			// IT1-2023-0000023 ADD END
// ANK-4475-00-00 ADD START
			.append(CSV + getStringToDblQuote(""))		// パートナー会員出力文章(卸でない場合は、空を挿入)
// ANK-4475-00-00 ADD END
			.append(System.getProperty(LINE_SEP));
		}

		// 最終行が空行だった場合、不要な行となるので出力しない(改ページで空白ページが出力される)
		// 未納合算分を出力しないようにしたために、最終行が空行になるケースが存在するための考慮

		// 出力文字列(String)
		String strOutString = sb.toString();

		// 出力文字列(String)がKUGYO_LINE_ENDで終わっている場合、最終行が空行と見なす
		if (strOutString.endsWith(KUGYO_LINE_END))
		{
			// 出力文字列のlength
			int sbLength = sb.length();

			// 改行文字列
			String kaigyoCode = System.getProperty(LINE_SEP);

			// 空行の前行の改行文字を探し、削除開始インデックスを取得
			// (出力文字列の改行文字が最後に見つかったインデックス -1)から先頭方向に改行文字を探し、
			// 「次に見つかったインデックス(=空行の前行の改行文字の開始インデックス) + 改行文字の長さ」を削除開始インデックスとする
			int deleteIndex = sb.lastIndexOf(kaigyoCode, sbLength -1 - kaigyoCode.length()) + kaigyoCode.length();

			// 削除開始インデックスから後の文字列を削除
			sb = sb.delete(deleteIndex, sbLength);
		}

		//UTF-8のバイト配列に変換して返す
		return sb.toString().getBytes("UTF-8");
	}

// ANK-4475-00-00 ADD START
	/**
	 * 卸料金グループ計の料金項目名称を取得する
	 * @param handle セッションハンドル
	 * @param param
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> execECH0391A010call(SessionHandle handle,IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		// 該当する料金項目名称を取得するためのKeyを設定(ネット：料金グループ計）
		String ech0391a010_prcGrpCd = "02";
		String ech0391a010_pcrsCd = "A88";
		String ech0391a010_prcSvcCd ="            ";
		String ech0391a010_prcKmkCd ="01900801601";
		/* ◇料金項目出力名称一意照会サービスインターフェイス */

		execECH0391A010(handle, param, chohyoReqMap, ech0391a010_prcGrpCd, ech0391a010_pcrsCd, ech0391a010_prcSvcCd, ech0391a010_prcKmkCd);
		parentMapCC.put("oroshi_net_prcgrpcd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_GRP_CD));
		parentMapCC.put("oroshi_net_pcrscd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PCRS_CD));
		parentMapCC.put("oroshi_net_prcsvccd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_SVC_CD));
		parentMapCC.put("oroshi_net_prckmkcd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_CD));
		parentMapCC.put("oroshi_net_prckmknm", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_NM));
		
		// 該当する料金項目名称を取得するためのKeyを設定(電話：料金グループ計）
		ech0391a010_prcGrpCd = "10";
		ech0391a010_pcrsCd = "A31";
		ech0391a010_prcSvcCd ="            ";
		ech0391a010_prcKmkCd ="01900801601";
		/* ◇料金項目出力名称一意照会サービスインターフェイス */

		execECH0391A010(handle, param, chohyoReqMap, ech0391a010_prcGrpCd, ech0391a010_pcrsCd, ech0391a010_prcSvcCd, ech0391a010_prcKmkCd);
		parentMapCC.put("oroshi_tel_prcgrpcd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_GRP_CD));
		parentMapCC.put("oroshi_tel_pcrscd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PCRS_CD));
		parentMapCC.put("oroshi_tel_prcsvccd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_SVC_CD));
		parentMapCC.put("oroshi_tel_prckmkcd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_CD));
		parentMapCC.put("oroshi_tel_prckmknm", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_NM));

		// 該当する料金項目名称を取得するためのKeyを設定(テレビ：料金グループ計）
		ech0391a010_prcGrpCd = "11";
		ech0391a010_pcrsCd = "A37";
		ech0391a010_prcSvcCd ="            ";
		ech0391a010_prcKmkCd ="01900801601";
		/* ◇料金項目出力名称一意照会サービスインターフェイス */

		execECH0391A010(handle, param, chohyoReqMap, ech0391a010_prcGrpCd, ech0391a010_pcrsCd, ech0391a010_prcSvcCd, ech0391a010_prcKmkCd);
		parentMapCC.put("oroshi_tv_prcgrpcd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_GRP_CD));
		parentMapCC.put("oroshi_tv_pcrscd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PCRS_CD));
		parentMapCC.put("oroshi_tv_prcsvccd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_SVC_CD));
		parentMapCC.put("oroshi_tv_prckmkcd", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_CD));
		parentMapCC.put("oroshi_tv_prckmknm", (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0391A010_PRC_KMK_NM));

		return parentMapCC;
	}

	/**
	 * 通信サービス料金内訳リスト情報(卸)をCSV形式のバイナリデータに変換する。
	 * @param handle セッションハンドル
	 * @param param
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param bothDispMap 内訳両出力マップ
	 * @param int 出力順No
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private byte[] makeCSVDataTushinSvcPrcUcwkOrsjgs(SessionHandle handle,IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap, HashMap<String, String> bothDispMap, int output_idx) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>) param.getData(MAP_ID);

		// 卸料金グループ計の料金項目名称を取得する
		// 初回のみ行う。
		if (output_idx == 0) {
			execECH0391A010call(handle, param, chohyoReqMap);
		}

		ArrayList childList = (ArrayList) parentMapCC.get("ECH0101B010CBSMsg1List");

		int len = childList.size();

		// 料金項目抽出変換一覧明細を取得
		List<HashMap<String, Object>> msgList2 = (ArrayList<HashMap<String, Object>>) parentMapCC.get(COL_ECH0401B010LIST2);

		// 「請求内訳明細非表示」の料金項目コードを取得しマップに設定する（キーのみ使用）
		HashMap<String, String> nonDispMap = new HashMap<String, String>();
		for (HashMap<String, Object> msg : msgList2)
		{
			StringBuilder key = new StringBuilder();
			key.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD))
				.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD))
				.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD))
				.append((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD));

			nonDispMap.put(key.toString(), null);
		}

		StringBuffer sb = new StringBuffer();

		// フォーマット編集
		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);

		// 発行番号
		String hakkoNum = editHakkoNo(parentMapCC);

		// 請求年月
		String seikyYm = ((String) parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM)).trim();

		String seikyYear = editYmd(seikyYm, DATE_KBN_YEAR);
		String seikyMonth = editYmd(seikyYm, DATE_KBN_MON);

		boolean kagami_bool = true;
		String temp_ctrl_flg = "";

		// 再計算用に詰めなおすList1
		// 料金グループ：ネットList
		ArrayList dataRecalRes_Net_List = new ArrayList();
		// 料金グループ：電話List
		ArrayList dataRecalRes_Tel_List = new ArrayList();
		// 料金グループ：テレビList
		ArrayList dataRecalRes_TV_List = new ArrayList();
		// 料金グループ：その他項目List
		ArrayList dataRecalRes_Others_List = new ArrayList();
		// 料金グループ：合計List
		ArrayList dataRecalRes_Total_List = new ArrayList();

		// フェーズ1:
		// 既存の処理で、残さないものは残さない。
		// サービス契約番号表示制御フラグに"1"でないものも残さない
		// 卸料金分類コード：3(債権譲渡)以外は残さない
		// ネット・電話・テレビ・他項目・合計にグループ分けして各々のListへ格納する
		
		for(int i = 0; i < len; i++) 
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);

			// 料金グループコード
			String prcGrpCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
			// 料金コースコード
			String pcrsCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
			// 料金サービスコード
			String prcSvcCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
			// 料金項目コード
			String prcKmkCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);

			// 請求内訳非表示判定キー
			StringBuilder prcKmkKey = new StringBuilder();
			prcKmkKey.append(prcGrpCd).append(pcrsCd).append(prcSvcCd).append(prcKmkCd);

			// 料金項目コードが業務機能識別コード(請求内訳明細非表示)に存在する場合、
			// 内訳明細として出力しない
			if (nonDispMap.containsKey(prcKmkKey.toString()))
			{
				continue;
			}

			// サービス契約番号表示制御フラグ
			temp_ctrl_flg = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_SVKEI_NO_DSP_CTRL_FLG);
			
			if(kagami_bool && (temp_ctrl_flg == null || "".equals(temp_ctrl_flg)))
			{
				kagami_bool = false;
				continue;
			}
			else if(kagami_bool)
			{
				continue;
			}
			
			// サービス契約番号表示制御フラグが"1"の場合、
			// 02,10,11,13の場合それぞれネット・電話・テレビのリストへ格納する。
			// 上記グループCD以外は取り除く
			if ("1".equals(temp_ctrl_flg)) {

				if ("02".equals(prcGrpCd)) {
					dataRecalRes_Net_List.add(msg);
					continue;
				} else if ("10".equals(prcGrpCd)) {
					dataRecalRes_Tel_List.add(msg);
					continue;
				} else if ("11".equals(prcGrpCd) || "13".equals(prcGrpCd)) {
					dataRecalRes_TV_List.add(msg);
					continue;
				} else {
					continue;
				}
			}

			// 料金項目コードが下記の場合、合計リストへ格納する
			if ("00900910601".equals(prcKmkCd)) {
				// 合計料金（Ａ＋Ｂ）：00900910601
				dataRecalRes_Total_List.add(msg);
				continue;
			} else if ("20900915601".equals(prcKmkCd)) {
				// 課税料金計（Ａ）：20900915601
				dataRecalRes_Total_List.add(msg);
				continue;
			} else if ("20900910201".equals(prcKmkCd)) {
				// うち消費税相当額（Ａ×１０／１１０）：20900910201
				dataRecalRes_Total_List.add(msg);
				continue;
			} else if ("10900915601".equals(prcKmkCd)) {
				// 課税料金計【８％】（Ａ）：10900915601
				dataRecalRes_Total_List.add(msg);
				continue;
			} else if ("10900910201".equals(prcKmkCd)) {
				// うち消費税相当額【８％】（Ａ×８／１０８）：10900910201
				dataRecalRes_Total_List.add(msg);
				continue;
			} else if ("00900910501".equals(prcKmkCd)) {
				// 非課税・不課税・免税等料金計（Ｂ）：00900910501
				dataRecalRes_Total_List.add(msg);
				continue;
			}

			// 卸料金分類コード
			String orosiPrcBriCd = (String) msg.get(JCHTushinSvcConstCC.ECH0101B010_OROSI_PRC_BRI_CD);
			// サービス契約番号
			String svcKeiNo = (String) msg.get(JCHTushinSvcConstCC.ECH0101B010_SVC_KEI_NO);

			// 卸料金分類コードが"3"以外の場合、格納せずスキップする
			if (!("3".equals(orosiPrcBriCd))) {
				continue;
			}

			// サービス契約番号がnullまたは空でない場合、
			// かつ、02,10,11,13の場合それぞれネット・電話・テレビのリストへ格納する。
			// サービス契約番号が半角スペースで来る可能性があるため、半角スペースを除去して判定する
			String svcKeiNo_Nospace = svcKeiNo.replace(" ", "");
			if (!(svcKeiNo_Nospace == null || "".equals(svcKeiNo_Nospace))) {
				if ("02".equals(prcGrpCd)) {
					dataRecalRes_Net_List.add(msg);
					continue;
				} else if ("10".equals(prcGrpCd)) {
					dataRecalRes_Tel_List.add(msg);
					continue;
				} else if ("11".equals(prcGrpCd) || "13".equals(prcGrpCd)) {
					dataRecalRes_TV_List.add(msg);
					continue;
				}
			}
			// これまでで該当しなかったものはその他項目リストへ格納する
			dataRecalRes_Others_List.add(msg);
		}

		// フェーズ2:
		// ネット・電話・テレビ の小計行 削除作成処理
		// 処理後、ネット・電話・テレビ・その他項目リストにデータが無い場合Skipフラグを設定しByteデータは空でreturnする。
		// 全リストから料金項目コード頭1桁目1(8%)が存在せず合計に8%がある場合合計行の8%は削除する
		// 8%が無い場合は、フラグを立てて8%再計算 及び 記事に入力する再計算額の8%部分は記載しないようにする

		int net_List_count = dataRecalRes_Net_List.size();
		int tel_List_count = dataRecalRes_Tel_List.size();
		int tv_List_count = dataRecalRes_TV_List.size();
		int other_List_count = dataRecalRes_Others_List.size();

		Boolean net_List_Not_Flg = false;
		Boolean tel_List_Not_Flg = false;
		Boolean tv_List_Not_Flg = false;
		Boolean other_List_Not_Flg = false;

		// その他項目リストが0件なら0件フラグを立てる
		if (other_List_count == 0) {
			other_List_Not_Flg = true;
		}

		// ネットリストの小計行削除作成処理を行う。
		if (net_List_count != 0) {
			HashMap<String, Object> msg1 = (HashMap<String, Object>) dataRecalRes_Net_List.get(0);
			// 1件目のサービス契約番号表示制御フラグ
			String temp_ctrl_flg1 = (String) msg1.get(JCHTushinSvcConstCC.ECH0101B010_SVKEI_NO_DSP_CTRL_FLG);

			// サービス契約番号表示制御フラグ:1の場合、
			// 2件目〜データが存在しなければネットListは削除しデータ無しフラグを立てる
			// 2件目〜データが存在すればそのままにする。
			if ("1".equals(temp_ctrl_flg1)) {
				if (net_List_count == 1) {
					dataRecalRes_Net_List.remove(0);
					net_List_Not_Flg = true;
				}
			} else {
				// 1件目に小計行ではない場合、
				// TOPに小計行を作成する処理に入る
				// 1件目のデータをコピーする(参照値違い)
				HashMap<String, Object> msg2 = new HashMap<String, Object>(msg1);

				// 編集に必要なものだけ格納値を小計行用に編集する
				msg2.put("tax_div_dsp_flg", "0");
				msg2.put("amnt_dsp_colum_cnt", "1");
				msg2.put("amnt_henshu_ptn_cd", "2");
				msg2.put("use_prd_dsp_ctrl_flg", "0");
				msg2.put("prc_grp_cd", (String) parentMapCC.get("oroshi_net_prcgrpcd"));
				msg2.put("pcrs_cd", (String) parentMapCC.get("oroshi_net_pcrscd"));
				msg2.put("prc_svc_cd", (String) parentMapCC.get("oroshi_net_prcsvccd"));
				msg2.put("prc_kmk_cd", (String) parentMapCC.get("oroshi_net_prckmkcd"));
				msg2.put("prc_kmk_nm", (String) parentMapCC.get("oroshi_net_prckmknm"));

				dataRecalRes_Net_List.add(0, msg2);
			}
		} else {
			net_List_Not_Flg = true;
		}

		// 電話リストの小計行削除作成処理を行う。
		if (tel_List_count != 0) {
			HashMap<String, Object> msg1 = (HashMap<String, Object>) dataRecalRes_Tel_List.get(0);
			// 1件目のサービス契約番号表示制御フラグ
			String temp_ctrl_flg1 = (String) msg1.get(JCHTushinSvcConstCC.ECH0101B010_SVKEI_NO_DSP_CTRL_FLG);

			// サービス契約番号表示制御フラグ:1の場合、
			// 2件目〜データが存在しなければネットListは削除しデータ無しフラグを立てる
			// 2件目〜データが存在すればそのままにする。
			if ("1".equals(temp_ctrl_flg1)) {
				if (tel_List_count == 1) {
					dataRecalRes_Tel_List.remove(0);
					tel_List_Not_Flg = true;
				}
			} else {
				// 1件目に小計行ではない場合、
				// TOPに小計行を作成する処理に入る
				// 1件目のデータをコピーする(参照値違い)
				HashMap<String, Object> msg2 = new HashMap<String, Object>(msg1);

				// 編集に必要なものだけ格納値を小計行用に編集する
				msg2.put("tax_div_dsp_flg", "0");
				msg2.put("amnt_dsp_colum_cnt", "1");
				msg2.put("amnt_henshu_ptn_cd", "2");
				msg2.put("use_prd_dsp_ctrl_flg", "0");
				msg2.put("prc_grp_cd", (String) parentMapCC.get("oroshi_tel_prcgrpcd"));
				msg2.put("pcrs_cd", (String) parentMapCC.get("oroshi_tel_pcrscd"));
				msg2.put("prc_svc_cd", (String) parentMapCC.get("oroshi_tel_prcsvccd"));
				msg2.put("prc_kmk_cd", (String) parentMapCC.get("oroshi_tel_prckmkcd"));
				msg2.put("prc_kmk_nm", (String) parentMapCC.get("oroshi_tel_prckmknm"));

				dataRecalRes_Tel_List.add(0, msg2);
			}
		} else {
			tel_List_Not_Flg = true;
		}

		// テレビリストの小計行削除作成処理を行う。
		if (tv_List_count != 0) {
			HashMap<String, Object> msg1 = (HashMap<String, Object>) dataRecalRes_TV_List.get(0);
			// 1件目のサービス契約番号表示制御フラグ
			String temp_ctrl_flg1 = (String) msg1.get(JCHTushinSvcConstCC.ECH0101B010_SVKEI_NO_DSP_CTRL_FLG);

			// サービス契約番号表示制御フラグ:1の場合、
			// 2件目〜データが存在しなければネットListは削除しデータ無しフラグを立てる
			// 2件目〜データが存在すればそのままにする。
			if ("1".equals(temp_ctrl_flg1)) {
				if (tv_List_count == 1) {
					dataRecalRes_TV_List.remove(0);
					tv_List_Not_Flg = true;
				}
			} else {
				// 1件目に小計行ではない場合、
				// TOPに小計行を作成する処理に入る
				// 1件目のデータをコピーする(参照値違い)
				HashMap<String, Object> msg2 = new HashMap<String, Object>(msg1);

				// 編集に必要なものだけ格納値を小計行用に編集する
				msg2.put("tax_div_dsp_flg", "0");
				msg2.put("amnt_dsp_colum_cnt", "1");
				msg2.put("amnt_henshu_ptn_cd", "2");
				msg2.put("use_prd_dsp_ctrl_flg", "0");
				msg2.put("prc_grp_cd", (String) parentMapCC.get("oroshi_tv_prcgrpcd"));
				msg2.put("pcrs_cd", (String) parentMapCC.get("oroshi_tv_pcrscd"));
				msg2.put("prc_svc_cd", (String) parentMapCC.get("oroshi_tv_prcsvccd"));
				msg2.put("prc_kmk_cd", (String) parentMapCC.get("oroshi_tv_prckmkcd"));
				msg2.put("prc_kmk_nm", (String) parentMapCC.get("oroshi_tv_prckmknm"));

				dataRecalRes_TV_List.add(0, msg2);
			}
		} else {
			tv_List_Not_Flg = true;
		}
		
		// その他項目リストの小計行削除処理を行う。
		// 債権譲渡以外取り除いた時、小計行だけ消えてその属する項目が存在することは考慮していない。
		// 例：1件目小計行２件目も小計行の場合、１件目の小計行に属する項目が無いと判断し１件目を削除する

		ArrayList<Integer> others_remove_List = new ArrayList<Integer>();

		for (int i = 0; i < dataRecalRes_Others_List.size(); i++) {

			HashMap<String, Object> msg2 = (HashMap<String, Object>) dataRecalRes_Others_List.get(i);
			if ("◇".regionMatches(0, (String) msg2.get("prc_kmk_nm"), 0, 1)) {
				boolean remove_flg = true;
				int start_point = i;
				for (int j = i + 1; j < dataRecalRes_Others_List.size(); j++) {
					HashMap<String, Object> msg3 = (HashMap<String, Object>) dataRecalRes_Others_List.get(j);
					if (!"◇".regionMatches(0, (String) msg3.get("prc_kmk_nm"), 0, 1)) {
						remove_flg = false;
						break;
					}
				}
				if (remove_flg) {
					others_remove_List.add(start_point);
				}
			}
		}
		// その他項目リストの削除indexListに値があればそのindexを対象にその他項目リストをremoveする。
		// 複数あることを考慮しindexズレを防ぐため降順で回していく。
		if (1 >= others_remove_List.size()) {
			Collections.reverse(others_remove_List);
			for (int i : others_remove_List) {
				dataRecalRes_Others_List.remove(i);
			}
		}
		// 合計リスト以外、0件の場合再計算対象項目が存在しないため
		// 料金履歴・対応履歴登録をSKIPするフラグを立て
		// 帳票出力データを空で返却する
		ArrayList<HashMap<String, Object>> key_List = getMapListItem(param, "tushin_svc_prc_output_list");
		HashMap<String, Object> kirokMap = key_List.get(output_idx);

		if (net_List_Not_Flg & tel_List_Not_Flg & tv_List_Not_Flg & other_List_Not_Flg) {

			// スキップフラグを立てる
			kirokMap.put("list_skip_flg", "1");

			// UTF-8のバイト配列に変換して返す
			return sb.toString().getBytes("UTF-8");
		}

		// 合計リスト以外のリストに8%科目CDが存在するか確認し
		// 存在しなければ合計リストの8%関連を削除する
		Boolean tax8_List_Not_Flg = true;

		// 各リスト内の料金項目コードの頭1桁目が1で存在すれば8%0件フラグをfalseに設定する
		// ネットリスト内確認
		for (int i = 0; i < dataRecalRes_Net_List.size(); i++) {

			HashMap<String, Object> msg5 = (HashMap<String, Object>) dataRecalRes_Net_List.get(i);
			if ("1".regionMatches(0, (String) msg5.get("prc_kmk_cd"), 0, 1)) {
				tax8_List_Not_Flg = false;
				break;
			}
		}
		// 電話リスト内確認
		if (tax8_List_Not_Flg) {
			for (int i = 0; i < dataRecalRes_Tel_List.size(); i++) {

				HashMap<String, Object> msg5 = (HashMap<String, Object>) dataRecalRes_Tel_List.get(i);
				if ("1".regionMatches(0, (String) msg5.get("prc_kmk_cd"), 0, 1)) {
					tax8_List_Not_Flg = false;
					break;
				}
			}
		}
		// テレビリスト内確認
		if (tax8_List_Not_Flg) {
			for (int i = 0; i < dataRecalRes_TV_List.size(); i++) {

				HashMap<String, Object> msg5 = (HashMap<String, Object>) dataRecalRes_TV_List.get(i);
				if ("1".regionMatches(0, (String) msg5.get("prc_kmk_cd"), 0, 1)) {
					tax8_List_Not_Flg = false;
					break;
				}
			}
		}
		// その他項目リスト内確認
		if (tax8_List_Not_Flg) {
			for (int i = 0; i < dataRecalRes_Others_List.size(); i++) {

				HashMap<String, Object> msg5 = (HashMap<String, Object>) dataRecalRes_Others_List.get(i);
				if ("1".regionMatches(0, (String) msg5.get("prc_kmk_cd"), 0, 1)) {
					tax8_List_Not_Flg = false;
					break;
				}
			}
		}
		
		// 8%0件フラグがtrueなら、合計リストの8%項目を削除する。なければそのまま
		if (tax8_List_Not_Flg) {
			for (int i = 0; i < dataRecalRes_Total_List.size(); i++) {
				HashMap<String, Object> msg5 = (HashMap<String, Object>) dataRecalRes_Total_List.get(i);
				if ("10900915601".equals((String) msg5.get("prc_kmk_cd"))) {
					// 課税料金計【８％】（Ａ）：10900915601が存在する場合、
					// うち消費税相当額【８％】（Ａ×８／１０８）：10900910201 も存在するので同時に消す
					dataRecalRes_Total_List.remove(i);
					// indexが1つ減ったので同じindexで削除
					dataRecalRes_Total_List.remove(i);
					break;
				}
			}
		}

		// フェーズ3:
		// 各Listの金額再計算再設定を行う
		int subTotal_Net_Amnt = 0;
		int subTotal_Tel_Amnt = 0;
		int subTotal_TV_Amnt = 0;
		int total_AB_Amnt = 0;
		int total_Tax10A_Amnt = 0;
		int total_InTax10A_Amnt = 0;
		int total_Tax8A_Amnt = 0;
		int total_InTax8A_Amnt = 0;
		int total_TaxExempt_Amnt = 0;

		// ネットリスト2件目から検索し再計算していく
		for (int i = 1; i < dataRecalRes_Net_List.size(); i++) {
			HashMap<String, Object> msg6 = (HashMap<String, Object>) dataRecalRes_Net_List.get(i);

			int net_amnt = Integer.parseInt((String) msg6.get("amnt"));
			subTotal_Net_Amnt += net_amnt;
			total_AB_Amnt += net_amnt;

			// 税区分表示が1なら非課税として合計行非課税に加算
			// 料金項目コードが10%項目なら合計行10%に加算
			// 料金項目コードが8%項目なら合計行8%に加算
			if ("1".equals((String) msg6.get("tax_div_dsp_flg"))) {
				total_TaxExempt_Amnt += net_amnt;
			} else if ("2".regionMatches(0, (String) msg6.get("prc_kmk_cd"), 0, 1)) {
				total_Tax10A_Amnt += net_amnt;
			} else if ("1".regionMatches(0, (String) msg6.get("prc_kmk_cd"), 0, 1)) {
				total_Tax8A_Amnt += net_amnt;
			}
		}
		// ネットの小計行に加算していた金額を再設定する。
		if (!net_List_Not_Flg) {
			HashMap<String, Object> msg_net = (HashMap<String, Object>) dataRecalRes_Net_List.get(0);
			msg_net.put("amnt", String.valueOf(subTotal_Net_Amnt));
		}

		// 電話リスト2件目から検索し再計算していく
		for (int i = 1; i < dataRecalRes_Tel_List.size(); i++) {
			HashMap<String, Object> msg6 = (HashMap<String, Object>) dataRecalRes_Tel_List.get(i);

			int tel_amnt = Integer.parseInt((String) msg6.get("amnt"));
			subTotal_Tel_Amnt += tel_amnt;
			total_AB_Amnt += tel_amnt;

			// 税区分表示が1なら非課税として合計行非課税に加算
			// 料金項目コードが10%項目なら合計行10%に加算
			// 料金項目コードが8%項目なら合計行8%に加算
			if ("1".equals((String) msg6.get("tax_div_dsp_flg"))) {
				total_TaxExempt_Amnt += tel_amnt;
			} else if ("2".regionMatches(0, (String) msg6.get("prc_kmk_cd"), 0, 1)) {
				total_Tax10A_Amnt += tel_amnt;
			} else if ("1".regionMatches(0, (String) msg6.get("prc_kmk_cd"), 0, 1)) {
				total_Tax8A_Amnt += tel_amnt;
			}
		}
		// 電話の小計行に加算していた金額を再設定する。
		if (!tel_List_Not_Flg) {
			HashMap<String, Object> msg_tel = (HashMap<String, Object>) dataRecalRes_Tel_List.get(0);
			msg_tel.put("amnt", String.valueOf(subTotal_Tel_Amnt));
		}
		
		// テレビリスト2件目から検索し再計算していく
		for (int i = 1; i < dataRecalRes_TV_List.size(); i++) {

			HashMap<String, Object> msg6 = (HashMap<String, Object>) dataRecalRes_TV_List.get(i);

			int tv_amnt = Integer.parseInt((String) msg6.get("amnt"));
			subTotal_TV_Amnt += tv_amnt;
			total_AB_Amnt += tv_amnt;

			// 税区分表示が1なら非課税として合計行非課税に加算
			// 料金項目コードが10%項目なら合計行10%に加算
			// 料金項目コードが8%項目なら合計行8%に加算
			if ("1".equals((String) msg6.get("tax_div_dsp_flg"))) {
				total_TaxExempt_Amnt += tv_amnt;
			} else if ("2".regionMatches(0, (String) msg6.get("prc_kmk_cd"), 0, 1)) {
				total_Tax10A_Amnt += tv_amnt;
			} else if ("1".regionMatches(0, (String) msg6.get("prc_kmk_cd"), 0, 1)) {
				total_Tax8A_Amnt += tv_amnt;
			}
		}
		// テレビの小計行に加算していた金額を再設定する。
		if (!tv_List_Not_Flg) {
			HashMap<String, Object> msg_tv = (HashMap<String, Object>) dataRecalRes_TV_List.get(0);
			msg_tv.put("amnt", String.valueOf(subTotal_TV_Amnt));
		}

		// その他項目リスト内金額再計算を行う。
		// その他項目リスト内は、複数の小計行が存在する可能性があるので
		// 小計行〜次の小計行までの属する項目を判定し金額を加算して
		// 次の小計行が来た際、もしくは最終件であれば始点の小計行に金額を再設定する。
		// またこのループ処理時に小計行のidex値を設定し、後の処理にて空行差し込みを行う。
		ArrayList<Integer> others_SubTotal_idx_List = new ArrayList<Integer>();

		for (int i = 0; i < dataRecalRes_Others_List.size(); i++) {

			HashMap<String, Object> msg6 = (HashMap<String, Object>) dataRecalRes_Others_List.get(i);
			if ("◇".regionMatches(0, (String) msg6.get("prc_kmk_nm"), 0, 1)) {
				int subTotal_Other_Amnt = 0;
				others_SubTotal_idx_List.add(i);
				for (int j = i + 1; j < dataRecalRes_Others_List.size(); j++) {
					HashMap<String, Object> msg7 = (HashMap<String, Object>) dataRecalRes_Others_List.get(j);

					if (!"◇".regionMatches(0, (String) msg7.get("prc_kmk_nm"), 0, 1)) {
						int other_Amnt = Integer.parseInt((String) msg7.get("amnt"));
						subTotal_Other_Amnt += other_Amnt;
						total_AB_Amnt += other_Amnt;

						// 税区分表示が1なら非課税として合計行非課税に加算
						// 料金項目コードが10%項目なら合計行10%に加算
						// 料金項目コードが8%項目なら合計行8%に加算
						if ("1".equals((String) msg7.get("tax_div_dsp_flg"))) {
							total_TaxExempt_Amnt += other_Amnt;
						} else if ("2".regionMatches(0, (String) msg7.get("prc_kmk_cd"), 0, 1)) {
							total_Tax10A_Amnt += other_Amnt;
						} else if ("1".regionMatches(0, (String) msg7.get("prc_kmk_cd"), 0, 1)) {
							total_Tax8A_Amnt += other_Amnt;
						}
					} else {
						msg6.put("amnt", String.valueOf(subTotal_Other_Amnt));
						break;
					}
					if (j + 1 == dataRecalRes_Others_List.size()) {
						msg6.put("amnt", String.valueOf(subTotal_Other_Amnt));
					}
				}
			}
		}

		// 各合計行に金額を再設定する。
		// うち消費税相当額の金額計算を行う

		total_InTax10A_Amnt = total_Tax10A_Amnt * 10 / 110;

		// 8%項目が存在する場合、8%のうち消費税相当額の金額計算を行う
		if (!tax8_List_Not_Flg) {
			total_InTax8A_Amnt = total_Tax8A_Amnt * 8 / 108;
		}

		for (int i = 0; i < dataRecalRes_Total_List.size(); i++) {

			HashMap<String, Object> msg9 = (HashMap<String, Object>) dataRecalRes_Total_List.get(i);
			// 料金項目コードが下記の場合、合計リストへ格納する
			if ("00900910601".equals((String) msg9.get("prc_kmk_cd"))) {
				// 合計料金（Ａ＋Ｂ）：00900910601
				msg9.put("amnt", String.valueOf(total_AB_Amnt));
			} else if ("20900915601".equals((String) msg9.get("prc_kmk_cd"))) {
				// 課税料金計（Ａ）：20900915601
				msg9.put("amnt", String.valueOf(total_Tax10A_Amnt));
			} else if ("20900910201".equals((String) msg9.get("prc_kmk_cd"))) {
				// うち消費税相当額（Ａ×１０／１１０）：20900910201
				msg9.put("amnt", String.valueOf(total_InTax10A_Amnt));
			} else if ("10900915601".equals((String) msg9.get("prc_kmk_cd"))) {
				// 課税料金計【８％】（Ａ）：10900915601
				msg9.put("amnt", String.valueOf(total_Tax8A_Amnt));
			} else if ("10900910201".equals((String) msg9.get("prc_kmk_cd"))) {
				// うち消費税相当額【８％】（Ａ×８／１０８）：10900910201
				msg9.put("amnt", String.valueOf(total_InTax8A_Amnt));
			} else if ("00900910501".equals((String) msg9.get("prc_kmk_cd"))) {
				// 非課税・不課税・免税等料金計（Ｂ）：00900910501
				msg9.put("amnt", String.valueOf(total_TaxExempt_Amnt));
			}
		}
		
		// 記事挿入用文字作成を行う
		String kiji = new String((String) kirokMap.get("list_init_kiji"));

		// YYYY/MM/DDを取得
		SimpleDateFormat sdf_fmt = new SimpleDateFormat(FMT_EDIT_YMD);
		String operateDate = (String) param.getControlMapData(SCControlMapKeys.OPE_DATE);
		String status_date = JPCFomatString.formatDate(operateDate);
		// String status_date = sdf_fmt.format(sdf_fmt.parse(operateDate));

		String recal_kiji = "";
		if (tax8_List_Not_Flg) {
			// 金額に,を付与する
			String comma_Total_Tax10A_Amnt = String.format("%,d", total_Tax10A_Amnt);
			String comma_Total_InTax10A_Amnt = String.format("%,d", total_InTax10A_Amnt);
			String comma_Total_TaxExempt_Amnt = String.format("%,d", total_TaxExempt_Amnt);
			recal_kiji = "【課税料金計（10%）：" + comma_Total_Tax10A_Amnt + "】【うち消費税計（10%）：" + comma_Total_InTax10A_Amnt + "】【非課税等：" + comma_Total_TaxExempt_Amnt + "】【状態：" + status_date + "】" + kiji;
		} else {
			// 金額に,を付与する
			String comma_Total_Tax10A_Amnt = String.format("%,d", total_Tax10A_Amnt);
			String comma_Total_InTax10A_Amnt = String.format("%,d", total_InTax10A_Amnt);
			String comma_Total_Tax8A_Amnt = String.format("%,d", total_Tax8A_Amnt);
			String comma_Total_InTax8A_Amnt = String.format("%,d", total_InTax8A_Amnt);
			String comma_Total_TaxExempt_Amnt = String.format("%,d", total_TaxExempt_Amnt);

			recal_kiji = "【課税料金計（10%）：" + comma_Total_Tax10A_Amnt + "】【うち消費税計（10%）：" + comma_Total_InTax10A_Amnt + "】【課税料金計（8%）：" + comma_Total_Tax8A_Amnt + "】【うち消費税計（8%）：" + comma_Total_InTax8A_Amnt + "】【非課税等：" + comma_Total_TaxExempt_Amnt + "】【状態：" + status_date + "】" + kiji;
		}

		// 記事が100文字を超える場合は切り捨てる
		if (recal_kiji.length() > 100) {
			recal_kiji = recal_kiji.substring(0, 100);
		}
		// 登録用の記事を再設定
		kirokMap.put("list_recal_kiji", recal_kiji);
		
		// フェーズ４
		// List毎に空行を差し込む
		// 空行差し込んだ後は１つのListにまとめる

		// 空行作成
		HashMap<String, Object> msg_Kugyou = new HashMap<String, Object>();

		msg_Kugyou.put("tax_div_dsp_flg", "");
		msg_Kugyou.put("amnt_dsp_colum_cnt", "");
		msg_Kugyou.put("amnt_henshu_ptn_cd", "");
		msg_Kugyou.put("use_prd_dsp_ctrl_flg", "");
		msg_Kugyou.put("prc_grp_cd", "");
		msg_Kugyou.put("pcrs_cd", "");
		msg_Kugyou.put("prc_svc_cd", "");
		msg_Kugyou.put("prc_kmk_cd", "");
		msg_Kugyou.put("prc_kmk_nm", "");
		msg_Kugyou.put("out_seiri_no", "");

		// ネットは、最終行に空行
		if (!net_List_Not_Flg) {
			dataRecalRes_Net_List.add(msg_Kugyou);
		}
		// 電話は、最終行に空行
		if (!tel_List_Not_Flg) {
			dataRecalRes_Tel_List.add(msg_Kugyou);
		}
		// テレビは、最終行に空行
		if (!tv_List_Not_Flg) {
			dataRecalRes_TV_List.add(msg_Kugyou);
		}

		// その他項目小計行IndexListを降順にする
		if (1 <= others_SubTotal_idx_List.size()) {
			Collections.reverse(others_SubTotal_idx_List);
			// 小計行の前行に空行を差し込む 最初の小計行だけ差し込まない
			for (int i : others_SubTotal_idx_List) {
				if (i != 0) {
					dataRecalRes_Others_List.add(i, msg_Kugyou);
				}
			}
		}
		// その他項目は、最終行に空行
		if (!other_List_Not_Flg) {
			dataRecalRes_Others_List.add(msg_Kugyou);
		}
		// 合計行は、空行を差し込まない

		// 1つのリストにまとめる
		ArrayList oroshi_hensyu = new ArrayList();

		for (int i = 0; i < dataRecalRes_Net_List.size(); i++) {
			HashMap<String, Object> msg10 = (HashMap<String, Object>) dataRecalRes_Net_List.get(i);
			oroshi_hensyu.add(msg10);
		}

		for (int i = 0; i < dataRecalRes_Tel_List.size(); i++) {
			HashMap<String, Object> msg10 = (HashMap<String, Object>) dataRecalRes_Tel_List.get(i);
			oroshi_hensyu.add(msg10);
		}

		for (int i = 0; i < dataRecalRes_TV_List.size(); i++) {
			HashMap<String, Object> msg10 = (HashMap<String, Object>) dataRecalRes_TV_List.get(i);
			oroshi_hensyu.add(msg10);
		}

		for (int i = 0; i < dataRecalRes_Others_List.size(); i++) {
			HashMap<String, Object> msg10 = (HashMap<String, Object>) dataRecalRes_Others_List.get(i);
			oroshi_hensyu.add(msg10);
		}

		for (int i = 0; i < dataRecalRes_Total_List.size(); i++) {
			HashMap<String, Object> msg10 = (HashMap<String, Object>) dataRecalRes_Total_List.get(i);
			oroshi_hensyu.add(msg10);
		}

		// 頭行にout_seiri_noを格納する。
		HashMap<String, Object> msg11 = (HashMap<String, Object>) oroshi_hensyu.get(0);
		msg11.put("out_seiri_no", editSeriNo((String) msg11.get(ECH0101B010CBSMsg1List.SEIRI_NO)));
		
		// フェーズ５
		// 明細行形成
		// 料金項目コードが業務機能識別コード(請求内訳明細非表示)に存在する場合、内訳明細として出力しない 処理を取り除いた以外は
		// makeCSVDataTushinSvcPrcUcwkメソッドの明細行形成と同じ処理
		
		
		// 明細行形成
		for(int i = 0; i < oroshi_hensyu.size(); i++) 
		{
			HashMap<String, Object> msg = (HashMap<String, Object>)oroshi_hensyu.get(i);

			// 料金グループコード
			String prcGrpCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
			// 料金コースコード
			String pcrsCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
			// 料金サービスコード
			String prcSvcCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
			// 料金項目コード
			String prcKmkCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);

			// 請求内訳非表示判定キー
			StringBuilder prcKmkKey = new StringBuilder();
			prcKmkKey.append(prcGrpCd).append(pcrsCd).append(prcSvcCd).append(prcKmkCd);

			// 料金項目コードが業務機能識別コード(請求内訳明細非表示)に存在する場合、
			// 内訳明細として出力しない
			if (nonDispMap.containsKey(prcKmkKey.toString()))
			{
				continue;
			}

			temp_ctrl_flg = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_SVKEI_NO_DSP_CTRL_FLG);
			
			if(kagami_bool && (temp_ctrl_flg == null || "".equals(temp_ctrl_flg)))
			{
				kagami_bool = false;
				continue;
			}
			else if(kagami_bool)
			{
				continue;
			}

			// 内訳額
			String ucwkGak = new String();
			// 内訳額
			String zeiKbn = new String();
			// 金額内訳
			String kinUcwk = new String();

			// 金額表示カラム数
			String amntDspColumCnt = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_DSP_COLUM_CNT);
			// 金額編集パターンコード
			String amntHenshuPtnCd = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT_HENSHU_PTN_CD);

			// 料金項目コードが業務機能識別コード(請求内訳両出力)に存在する場合、金額、金額内訳両方に出力する
			if (bothDispMap.containsKey(prcKmkKey.toString()))
			{
				ucwkGak = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				ucwkGak = editAmnt(ucwkGak, amntHenshuPtnCd);
				kinUcwk = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				kinUcwk = editAmnt(kinUcwk, amntHenshuPtnCd);
			}
			// 金額カラム数"0"の場合、金額・金額内訳共に未設定
			else if (amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_ZERO))
			{
				ucwkGak = new String();
				kinUcwk = new String();
			}
			// 金額カラム数"1"の場合、金額に設定
			else if(amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_UCWK_AMNT))
			{
				ucwkGak = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				ucwkGak = editAmnt(ucwkGak, amntHenshuPtnCd);
			}
			// 金額カラム数"2"の場合、金額内訳に設定
			else if(amntDspColumCnt.equals(JACStrConst.AMNT_DSP_COLUM_CNT_TWO))
			{
				kinUcwk = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				kinUcwk = editAmnt(kinUcwk, amntHenshuPtnCd);
			}
			// 上記以外の場合、金額・金額内訳共に設定
			else
			{
				ucwkGak = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				ucwkGak = editAmnt(ucwkGak, amntHenshuPtnCd);
				kinUcwk = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				kinUcwk = editAmnt(kinUcwk, amntHenshuPtnCd);
			}

			if (null != msg.get(JCHTushinSvcConstCC.ECH0101B010_TAX_DIV_DSP_FLG)
					&& "1".equals((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_TAX_DIV_DSP_FLG)))
			{
				zeiKbn = "*";
			}
			else
			{
				zeiKbn = ""; 
			}

			// 利用期間
			String useKikan = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_KIKAN);
			
			if(JACStrConst.USE_PRD_DSP_CTRL_FLG_ON.equals((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_PRD_DSP_CTRL_FLG)))
			{
				/*---< #81816 MOD start >---*/
//				useKikan = JCHCommonFormatUtil.convRiyoKikan(useKikan);
				//料金グループコード　＝　"51"(ｍｉｎｅｏ)  かつ　利用終了年月日の年月　＜　請求年月の場合、空文字を設定
				if ((prcGrpCd != null && prcGrpCd.equals("51"))
						&& ((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_ENDYMD) != null && ((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_ENDYMD)).length() == 8)
						&& ((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_SEIKY_YM) != null && ((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_SEIKY_YM)).length() == 6)
						&& (((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_USE_ENDYMD)).substring(0,6).compareTo((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_SEIKY_YM)) < 0)
					)
				{
					useKikan = JACStrConst.KARA_MOJI;
				}
				else
				{
					// 半角数字を全角に変換
					useKikan = JCHCommonFormatUtil.convRiyoKikan(useKikan);
				}
				/*---< #81816 MOD end >---*/
			}
			else
			{
				useKikan = JACStrConst.KARA_MOJI;
			}

			// 料金項目名称
			String strPrcKmkNm = (String)msg.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_NM);

			// 料金項目名称（すでに全角に変換済）が30文字を超える場合は切り捨てる
			if (strPrcKmkNm.length() > 30)
			{
				strPrcKmkNm = strPrcKmkNm.substring(0, 30);
			}

			// ANK-4401-00-00 ADD START
			// 追加タイトル
			String addTitle = new String();
			String prc_chg_flg = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_PRC_CHGE_FLG);

			// 料金変更フラグが「"1"：変更済」の場合、追加タイトルに"<修正>"を設定する
			if (JACStrConst.PRC_CHG_FLG.equals(prc_chg_flg))
			{
				addTitle = "<修正>";
			}
			else
			{
				addTitle = JACStrConst.KARA_MOJI;
			}
			
			// 適格請求書発行事業者登録番号
			String TkkkSksHakkoJigyoshaAddNo = (String)parentMapCC.get(JCHTushinSvcConstCC.EZM0311A010_SYS_PARAM_SETTE_VALUE_1);
			
			// 料金変更フラグが「"1"：変更済」の場合、追加タイトルに"<修正>"を設定する
			if (TkkkSksHakkoJigyoshaAddNo == null)
			{
				TkkkSksHakkoJigyoshaAddNo = JACStrConst.KARA_MOJI;
			}
			// ANK-4401-00-00 ADD END

			sb.append(getStringToDblQuote((String)sohusNmList.get(0)))					// 送付先名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))				// 送付先部課名
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))				// 送付先担当者名
			.append(CSV + getStringToDblQuote((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO)))		// お客様番号
			.append(CSV + getStringToDblQuote(hakkoNum))		// 発行番号
//			.append(CSV + nengo)			// 請求年月年号
			.append(CSV + getStringToDblQuote(seikyYear))		// 請求年月（年）
			.append(CSV + getStringToDblQuote(seikyMonth))		// 請求年月（月）

			.append(CSV + getStringToDblQuote((String)msg.get(JCHTushinSvcConstCC.ECH0101B010_OUT_SEIRI_NO)))					// NO
			.append(CSV + getStringToDblQuote(strPrcKmkNm))		// 料金内訳
			.append(CSV + getStringToDblQuote(zeiKbn))			// 税区分
			.append(CSV + getStringToDblQuote(ucwkGak))			// 内訳額
			.append(CSV + getStringToDblQuote(kinUcwk))			// 金額内訳
			.append(CSV + getStringToDblQuote(useKikan))		// 利用期間
			// ANK-4401-00-00 ADD START
			// IT1-2023-0000023 DEL START
//			.append(CSV + getStringToDblQuote(TkkkSksHakkoJigyoshaAddNo))		// 適格請求書発行事業者登録番号
			// IT1-2023-0000023 DEL END
			.append(CSV + getStringToDblQuote(addTitle))		// 追加タイトル
			// ANK-4401-00-00 ADD END
			// IT1-2023-0000023 ADD START
			.append(CSV + getStringToDblQuote(TkkkSksHakkoJigyoshaAddNo))		// 適格請求書発行事業者登録番号
			// IT1-2023-0000023 ADD END
			.append(CSV + getStringToDblQuote(OROSI_OUTPUT_TEXT))		// パートナー会員出力文章

			.append(System.getProperty(LINE_SEP));
		}

		// 最終行が空行だった場合、不要な行となるので出力しない(改ページで空白ページが出力される)
		// 未納合算分を出力しないようにしたために、最終行が空行になるケースが存在するための考慮

		// 出力文字列(String)
		String strOutString = sb.toString();

		// 出力文字列(String)がKUGYO_LINE_ENDで終わっている場合、最終行が空行と見なす
		if (strOutString.endsWith(KUGYO_LINE_END))
		{
			// 出力文字列のlength
			int sbLength = sb.length();

			// 改行文字列
			String kaigyoCode = System.getProperty(LINE_SEP);

			// 空行の前行の改行文字を探し、削除開始インデックスを取得
			// (出力文字列の改行文字が最後に見つかったインデックス -1)から先頭方向に改行文字を探し、
			// 「次に見つかったインデックス(=空行の前行の改行文字の開始インデックス) + 改行文字の長さ」を削除開始インデックスとする
			int deleteIndex = sb.lastIndexOf(kaigyoCode, sbLength -1 - kaigyoCode.length()) + kaigyoCode.length();

			// 削除開始インデックスから後の文字列を削除
			sb = sb.delete(deleteIndex, sbLength);
		}

		//UTF-8のバイト配列に変換して返す
		return sb.toString().getBytes("UTF-8");
	}
// ANK-4475-00-00 ADD END
	
	// ▼▼ クラス内共通処理 ▼▼

	/**
	 * 編集した送付先住所を返します。
	 * @param parentMapCC
	 * @param editFlgMap
	 * @return ArrayList
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
// 2014.06.04 OM-2014-0001921 mod start
//	private ArrayList<String> editSohusaki(HashMap<String, Object> parentMapCC) throws Exception
	private ArrayList<String> editSohusaki(HashMap<String, Object> parentMapCC, HashMap<String, String> editFlgMap) throws Exception
// 2014.06.04 OM-2014-0001921 mod end
	{
		ArrayList<String> addList = new ArrayList<String>();
		addList.add("");
		addList.add("");
		addList.add("");
		addList.add("");

		String zuijiFlg = (String)parentMapCC.get("zuijiFlg");
		String[] paramEditAddr = new String[7];

		if(ZUIJI_FLG.equals(zuijiFlg))
		{
			ArrayList seikyKeiykList = (ArrayList)parentMapCC.get("seikyKeiykList");
			HashMap<String, Object> seikyKeiykMap = (HashMap<String, Object>)seikyKeiykList.get(0);

			paramEditAddr[0] = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_STATE_NM);
			paramEditAddr[1] = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_CITY_NM);
			paramEditAddr[2] = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_OAZTSU_NM);
			paramEditAddr[3] = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_AZCHO_NM);
			paramEditAddr[4] = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BNCHIGO);
			paramEditAddr[5] = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRTTM);
			paramEditAddr[6] = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRRM);
		}
		else
		{
			paramEditAddr[0] = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_STATE_NM);
			paramEditAddr[1] = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_CITY_NM);
			paramEditAddr[2] = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_OAZTSU_NM);
			paramEditAddr[3] = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_AZCHO_NM);
			paramEditAddr[4] = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BNCHIGO);
			paramEditAddr[5] = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRTTM);
			paramEditAddr[6] = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRRM);
		}

		JCHCommonFormatUtil chComFmtUtil = new JCHCommonFormatUtil();

		// 通常文字サイズで編集
		String[] retEditAddr = chComFmtUtil.editAddress(paramEditAddr, ADDRESS_NORMAL_LINE_LENGTH, ADDRESS_SPLIT_COUNT);

		if (retEditAddr != null)
		{
// 2014.06.04 OM-2014-0001921 add start
			editFlgMap.put(EDIT_FLG_KEY, EDIT_FLG_NORMAL);
//2014.06.04 OM-2014-0001921 add end
			if (!retEditAddr[0].equals(JCHCommonFormatUtil.EDIT_RESULT_NORMAL))
			{
				// 小さい文字サイズで編集
				retEditAddr = chComFmtUtil.editAddress(paramEditAddr, ADDRESS_SMALL_LINE_LENGTH, ADDRESS_SPLIT_COUNT);
// 2014.06.04 OM-2014-0001921 add start
				editFlgMap.put(EDIT_FLG_KEY, EDIT_FLG_SMALL);
// 2014.06.04 OM-2014-0001921 add end
			}
			
			for (int i = 1; i < retEditAddr.length; i++)
			{
				addList.set(i - 1, retEditAddr[i]);
			}
		}

		return addList;
	}

	/**
	 * 編集した発行番号を返します。
	 * @param parentMapCC
	 * @return String
	 * @throws Exception
	 */
	private String editHakkoNo(HashMap<String, Object> parentMapCC) throws Exception
	{
		StringBuffer sb = new StringBuffer();

		sb.append(((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_YM)).substring(2, 6));				// 請求年月(YYMM)
		sb.append(JACStrConst.HYPHEN);
		sb.append((String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_KEY_SEIKY_KEI_NO));						// お客様番号(請求先番号)
		sb.append(JACStrConst.HYPHEN);
		sb.append((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_WAY_CD));							// 支払方法
		sb.append(JCHTushinSvcConstCC.SEQ_NO);																		// シーケンス番号("00"固定)
		// 定例請求の場合、"00"固定
		String seikySbtCd = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_SBT_CD);
		if(JACStrConst.SIKYSHBTS_TEIGK_SEIKY.equals(seikySbtCd))
		{
			sb.append(JCHTushinSvcConstCC.HAKKO_MONTH);
		}
		else
		{
			String hakkoYmd = ((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SEIKYUS_HAKKO_YMD)).trim();	// 発行月(MM)
			sb.append(editYmd(hakkoYmd, DATE_KBN_MON));
		}
		sb.append(((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_SKS_HAKKO_SEQ)).trim().substring(1, 2));	// 発行シーケンス(下1桁)
		sb.append(JCHTushinSvcConstCC.GUN);																			// 群("6"固定)
		sb.append(JCHTushinSvcConstCC.SEIKYSYO_KBN);																// 請求書区分("1"固定)

		return sb.toString();
	}

	/**
	 * 編集した年・月・日を返します。
	 * @param strDate
	 * @param kbnYmd
	 * @return String
	 * @throws Exception
	 */
	private String editYmd(String strDate, String kbnYmd) throws Exception
	{
		String rtnValue = JACStrConst.KARA_MOJI;

		if(strDate != null && !JACStrConst.KARA_MOJI.equals(strDate))
		{
			if (DATE_KBN_YEAR.equals(kbnYmd))
			{
				// 年の切り出し
				rtnValue = strDate.substring(0, 4);
			}
			else if (DATE_KBN_MON.equals(kbnYmd))
			{
				// 月の切り出し
				rtnValue = strDate.substring(4, 6);
			}
			else if (DATE_KBN_DAY.equals(kbnYmd))
			{
				// 日の切り出し
				rtnValue = strDate.substring(6, 8);
			}
		}

		return rtnValue;
	}

	/**
	 * サービスインタフェースに渡すパラメータマップを新規に作成します。
	 * マップには共通項目である電文ヘッダ、コントロールマップを設定します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return paramMap
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private HashMap<String, Object> createNewParamMap(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		/* ◇電文ヘッダ */
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

		/* ◇コントロールマップ */
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		return paramMap;
	}

	/**
	 * テンプレートの共通項目を設定します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param template テンプレート
	 * @param templateIdKey テンプレートIDキー名
	 * @param templateIdVal テンプレートID値
	 * @param templateFuncCdKey テンプレート機能コードキー名
	 * @return template
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private CAANMsg setTemplateCommonItem(IRequestParameterReadWrite param, CAANMsg template, 
											String templateIdKey, String templateIdVal, String templateFuncCdKey) throws RequestParameterException
	{
		// テンプレートID
		template.set(templateIdKey, templateIdVal);

		// 機能コード（デフォルト：１）
		template.set(templateFuncCdKey, JPCModelConstant.FUNC_CD_1);

		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);

		return template;
	}

	/**
	 * 文字列を「"」で囲みます。
	 * @param arg0 対象文字列
	 * @return "対象文字列"
	 */
	private String getStringToDblQuote(String arg0)
	{
		return SINGLE_DBLQUOTE + arg0 + SINGLE_DBLQUOTE;
		
	}
//	// ▲▲ クラス内共通処理 ▲▲
//	/**
//	 * 西暦を和暦に変換し、元号、年、月、日に分割されたものを配列で返却します。
//	 * <pre>
//	 * ≪返却される文字列配列の例≫
//	 *     [ "平成", "23", "12" , "8" ]
//	 * </pre>
//	 * @param date 年月日(8桁)
//	 * @return 和暦の文字列配列
//	 * @throws JCCCalendarException
//	 */
//	public static String[] toJapaneseYmdArray(String date) throws JCCCalendarException
//	{
//		String delims = "/";
//		return new JCCJapaneseCalendar(new JCCWestCalendar(date).toJapaneseCalendar()).toCcString(delims, delims, delims, delims).split(delims);
//	}

	/**
	 * 対象日付の曜日を取得します。
	 * <br>
     * @param arg0 対象日付
     * @return String 曜日（1:日曜日〜7:土曜日）
     */
	public String getDayOfWeek(String arg0) 
	{
		if (!isValidParameter(arg0, YMD) && !isValidParameter(arg0, YMDHMS)) 
		{
			throw new IllegalArgumentException("引数の文字列[" + arg0 + "]" + "は不正です。");
		}

		// 曜日（返却値）
		String dayOfWeek = "";

		// 日付妥当性チェック
		if (!checkDate(arg0, 8)) 
		{
			return dayOfWeek;
		}

		// カレンダーオブジェクトを生成する
		int year = Integer.parseInt(arg0.substring(0, 4)); 	// 年

		int month = Integer.parseInt(arg0.substring(4, 6)); 	// 月
		
		int day = Integer.parseInt(arg0.substring(6, 8)); 	// 日

		GregorianCalendar cal = new GregorianCalendar(year, month - 1, day);

		// 曜日を取得する
		dayOfWeek = String.valueOf(cal.get(GregorianCalendar.DAY_OF_WEEK));

		return getDayNm(dayOfWeek);
	}
	
	/**
	 * 対象日付の曜日を取得します。
	 * <br>
     * @param dayNo 対象日付
     * @return dayNm 曜日（1:日〜7:土）
     */
	private static String getDayNm(String dayNo)
	{
		String dayNm = "";

		if (DAY1_CODE.equals(dayNo))
		{
			dayNm = DAY1_NM ;
		} 
		else if (DAY2_CODE.equals(dayNo))
		{
			dayNm = DAY2_NM ;
		} 
		else if (DAY3_CODE.equals(dayNo))
		{
			dayNm = DAY3_NM ;
		}
		else if (DAY4_CODE.equals(dayNo))
		{
			dayNm = DAY4_NM ;
		}
		else if (DAY5_CODE.equals(dayNo))
		{
			dayNm = DAY5_NM ;
		}
		else if (DAY6_CODE.equals(dayNo))
		{
			dayNm = DAY6_NM ;
		}
		else if (DAY7_CODE.equals(dayNo))
		{
			dayNm = DAY7_NM ;
		}
		return dayNm;
	}
	
	/**
	 * 有効なパラメータか判定します。
	 * 文字列に値が設定されていない場合、及び指定された桁数と
	 * 一致しない場合はエラーとします。
	 * <br>
	 * @param arg0 判定する文字列
	 * @param arg1 文字列として有効な桁数
	 * @return パラメータが不正な場合はfalse
	 */
	protected static boolean isValidParameter(String arg0, int arg1) 
	{
		if (null == (arg0))
		{
			return false;
		}

		return arg1 == arg0.length();
	}

	/**
     * 日付の妥当性チェックを行います。
     * <br>
     * @param date yyyyMMddもしくはyyyyMM形式の日付
     * @param length チェック対象の日付の桁数
     * @return boolean
     */
	private static boolean checkDate(String date, int length) 
	{
		// 引数チェック
		if (null == (date)) 
		{
			return false;
		}

		try 
		{
			int yyyy = Integer.parseInt(date.substring(0, 4));

			int mm = Integer.parseInt(date.substring(4, 6));

			int dd = 1;

			if (length == 8) 
			{
				dd = Integer.parseInt(date.substring(6, 8));
			}

			// 月は 0 から始まる。（0:１月 となる。）
			Calendar cl = new GregorianCalendar(yyyy, mm - 1, dd);

			// カレンダークラスにより、日付が調整されてしまっている場合は、エラーである。
			if ((cl.get(Calendar.YEAR) != yyyy) 
					|| ((cl.get(Calendar.MONTH) + 1) != mm) 
					|| (cl.get(Calendar.DATE) != dd)) 
			{
				return false;
			}
			else 
			{
				return true;
			}
		}
		catch (NumberFormatException e) 
		{
			return false;
		}
	}

	/**
	 * 編集した金額を返します。
	 * @param strAmnt
	 * @param amntHenshuPtnCd
	 * @return String
	 * @throws Exception
	 */
	private String editAmnt(String strAmnt, String amntHenshuPtnCd) throws Exception
	{
		String editAmnt = JACStrConst.KARA_MOJI;
		String rtnValue = JACStrConst.KARA_MOJI;

		if(strAmnt != null && !JACStrConst.KARA_MOJI.equals(strAmnt))
		{
			// 金額編集パターンコードが"0"(編集なし)の場合
			if (AMNT_HENSHU_PTN_CD_0.equals(amntHenshuPtnCd))
			{
				rtnValue = JPCUtilCommon.fillHalfSpace(strAmnt, AMNT_HENSHU_KETA_MAX, false);
			}
			// 金額編集パターンコードが"1"(括弧あり)の場合
			else if (AMNT_HENSHU_PTN_CD_1.equals(amntHenshuPtnCd))
			{
				editAmnt = KNGK_KAKKO_ARI_L + strAmnt + KNGK_KAKKO_ARI_R;
				rtnValue = JPCUtilCommon.fillHalfSpace(editAmnt, AMNT_HENSHU_KETA_MAX, false);
			}
			// 金額編集パターンコードが"2"(括弧インデントあり)の場合
			else if (AMNT_HENSHU_PTN_CD_2.equals(amntHenshuPtnCd))
			{
				rtnValue = JPCUtilCommon.fillHalfSpace(strAmnt, AMNT_HENSHU_KETA_KAKKO_IDT, false);
			}
		}
		return rtnValue;
	}

	/**
	 * 編集したお客様名を返します。
	 * @param parentMapCC
	 * @return String
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<String> editSohusakiName(HashMap<String, Object> parentMapCC) throws Exception
	{
		ArrayList<String> nameList = new ArrayList<String>();

		String zuijiFlg = (String)parentMapCC.get("zuijiFlg");
		String sohusNm = "";
		String sohusBkm = "";
		String sohusTntshaNm = "";
		if(ZUIJI_FLG.equals(zuijiFlg))
		{
			ArrayList seikyKeiykList = (ArrayList)parentMapCC.get("seikyKeiykList");
			HashMap<String, Object> seikyKeiykMap = (HashMap<String, Object>)seikyKeiykList.get(0);
			sohusNm = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_NM);
			sohusBkm = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BKM);
			sohusTntshaNm = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_TNTSHA_NM);
		}
		else
		{
			sohusNm = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_NM);
			sohusBkm = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BKM);
			sohusTntshaNm = (String)parentMapCC.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_TNTSHA_NM);
		}

		nameList.add(JACCommonUtil.editStrLength(sohusNm, CHOHYO_OUT_NAME_LENGTH));
		nameList.add(JACCommonUtil.editStrLength(sohusBkm, CHOHYO_OUT_NAME_LENGTH));
		nameList.add(JACCommonUtil.editStrLength(sohusTntshaNm, CHOHYO_OUT_NAME_LENGTH));
		ArrayList<String> resultNameList = JACCommonUtil.editNameList(nameList);

		return resultNameList;
	}

	/**
	 * 帳票出力用に編集したカスタマバーコードを返します。
	 * @param parentMapCC
	 * @return editCustBarCd
	 * @throws Exception
	 */
	@SuppressWarnings({ "unchecked", "static-access" })
	private String editOutputCustomerBarCd(HashMap<String, Object> parentMapCC) throws Exception
	{
		String zuijiFlg = (String)parentMapCC.get("zuijiFlg");
		String customerBarCd = JACStrConst.KARA_MOJI;
		if(ZUIJI_FLG.equals(zuijiFlg))
		{
			ArrayList seikyKeiykList = (ArrayList)parentMapCC.get("seikyKeiykList");
			HashMap<String, Object> seikyKeiykMap = (HashMap<String, Object>)seikyKeiykList.get(0);
			// 送付先郵便番号
			String sohusPcd = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_PCD);
			// 送付先大字通称名
			String sohusOaztsuNm = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_OAZTSU_NM);
			// 送付先字丁目名
			String sohusAzcho = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_AZCHO_NM);
			// 送付先住所番地号
			String sohusBnchigo = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_BNCHIGO);
			// 送付先住所補記・建物名
			String sohusAdrttm = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRTTM);
			// 送付先住所補記・部屋番号
			String sohusAdrrm = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.EKK0491A010_SOHUS_ADRRM);
			
			// カスタマバーコードリスト取得
			JCHCommonBarcodeEdit commonBarcodeEdiCst = new JCHCommonBarcodeEdit();

			List<String> customerBarcodeList = 
					commonBarcodeEdiCst.getCustomerBarcode(sohusPcd, sohusOaztsuNm, sohusAzcho, sohusBnchigo, sohusAdrttm, sohusAdrrm);
			
			// カスタマバーコードリストを連結して文字列に編集
			StringBuffer sbCustBcd = new StringBuffer();
			
			if (customerBarcodeList != null)
			{
				// カスタマスタートビット
				sbCustBcd.append(customerBarcodeList.get(0));
				// カスタマ送付先郵便番号
				sbCustBcd.append(customerBarcodeList.get(1));
				// カスタマ送付先住所コード
				sbCustBcd.append(customerBarcodeList.get(2));
				// カスタマチェックデジット
				sbCustBcd.append(customerBarcodeList.get(3));
				// カスタマストップビットコード
				sbCustBcd.append(customerBarcodeList.get(4));
			}
			customerBarCd = sbCustBcd.toString();

		}
		String editCustBarCd = JCHCommonBarcodeEdit.outputListCreator(customerBarCd);
		return editCustBarCd;
	}

	/**
	 * 整理番号編集
	 * 
	 * @param seiriNo ：整理番号
	 * @return editSeiriNo 編集後の整理番号
	 * @throws Exception 
	 */
	public String editSeriNo(String seiriNo) throws Exception
	{
		// 整理番号が未入力である場合
		if (seiriNo == null || seiriNo.trim().length() == 0)
		{
			return "";
		}
		else
		{
			// 上記以外である場合にはハイフンを挿入する
			String editSeiriNo = JCHCommonFormatUtil.formatSeiriNo(seiriNo);
			return editSeiriNo;
		}
	}
	
	/**
	 * 業務パラメータ管理情報取得
	 * 
	 * @param param
	 * @return workParamMap
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, String> getWorkParamKnri(IRequestParameterReadWrite param) throws Exception
	{
		HashMap<String, Object> workParamMapCC = null;
		workParamMapCC = (HashMap<String, Object>)param.getData(GETWORKPARAMLISTCC);

		ArrayList childList = null;
		HashMap<String, String> workParamMap = new HashMap<String, String>();
		
		// 業務パラメータ管理情報取得CCから値を取得
		if(workParamMapCC != null && workParamMapCC.containsKey(EZM0321A010CBSMSG1LIST))
		{
			childList = (ArrayList)workParamMapCC.get(EZM0321A010CBSMSG1LIST);

			for(int i = 0; i < childList.size(); i++)
			{
				HashMap<String, Object> msg = (HashMap<String, Object>)childList.get(i);

				// 業務パラメータID
				String workParamId = (String)msg.get(EZM0321A010CBSMsg1List.WORK_PARAM_ID);
				// 業務パラメータ設定値
				String workParamValue = (String)msg.get(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
				
				workParamMap.put(workParamId, workParamValue);
			}
		}
		return workParamMap;
	}

	/**
	 * 指定された月日のゼロサプレス編集
	 * 
	 * @param strValue ：編集前文字列
	 * @return strValue ：編集後文字列
	 * @throws Exception 
	 */
	public String editZeroSpace(String strValue) throws Exception
	{
		// 文字列が未入力である場合
		if (strValue == null || strValue.trim().length() == 0)
		{
			return "  ";
		}
		else
		{
			if(strValue.startsWith("0", 0))
			{
				// １文字目が"0"の場合は空白に置き換える
				strValue = strValue.replaceFirst(ZERO, JACStrConst.SPACE_1);
			}
			return strValue;
		}
	}

	/**
	 * 編集したお知らせを返します。
	 * @param parentMapCC
	 * @param zuijiFlg
	 * @return ArrayList
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<String> editInformation(HashMap<String, Object> parentMapCC) throws Exception
	{
		String zuijiFlg = (String)parentMapCC.get("zuijiFlg");

		ArrayList<String> infoList = new ArrayList<String>();
		if(ZUIJI_FLG.equals(zuijiFlg))
		{
			ArrayList seikyKeiykList = (ArrayList)parentMapCC.get("seikyKeiykList");
			HashMap<String, Object> seikyKeiykMap = (HashMap<String, Object>)seikyKeiykList.get(0);
			String information = (String)seikyKeiykMap.get(JCHTushinSvcConstCC.INFORMATION);
			if(!"".equals(information))
			{
				String[] strList = information.split("\r\n");
				for(String strInfo : strList)
				{
					if(infoList.size() > 8)
					{
						break;
					}
					while(strInfo.length() > 32)
					{
						infoList.add(strInfo.substring(0, 32));
						StringBuilder sb = new StringBuilder(strInfo);
						strInfo = sb.delete(0, 32).toString();
					}
					infoList.add(strInfo);
				}
			}
		}
		int infoSize = infoList.size();
		
		for(int i = infoSize; i < 8; i++)
		{
			infoList.add(JACStrConst.KARA_MOJI);
		}
		ArrayList<String> resultInfoList = infoList;

		return resultInfoList;
	}

	/**
	 * 消費税金額の編集（マスク化制御）を実行し、結果をリターンする。
	 * @param param
	 * @return HashMap
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private String getZeiAmnt(IRequestParameterReadWrite param, String chohyoKbn) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		// 消費税（返却値）
		String tax = "";

		// 合算フラグ
		String gsanFlg = "";

		// 前受充当金額フラグ
		String maeukJutoFlg = "";

		// 一部収納判定フラグ[true:一部収納である、false:一部収納でない]
		boolean ichbuShuno = false;
		
		// IT1-2023-0000051 ADD START
		// 消費税（編集）
		String taxEdit = "";
		taxEdit = parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_STAX_AMNT).toString();
		
		// 消費税がマイナスの場合、マスク
		if (taxEdit.length() > 0 && Long.parseLong(taxEdit) < 0) 
		{
			tax = MASK_HN_15;
		}
		// IT1-2023-0000051 ADD END

		// 窓口の場合
		// IT1-2023-0000051 MOD START
		// ANK-3838-00-00 MOD START
		//if (LIST_KBN_MADO.equals(chohyoKbn))
//		if (LIST_KBN_MADO.equals(chohyoKbn) || LIST_KBN_MADO_CUST.equals(chohyoKbn))
		else if (LIST_KBN_MADO.equals(chohyoKbn) || LIST_KBN_MADO_CUST.equals(chohyoKbn))
		// ANK-3838-00-00 MOD 
		// IT1-2023-0000051 MOD END
		{
			// 再請求登録SCマップ
			HashMap<String, Object> chsv003901MapCC = (HashMap<String, Object>)param.getData(MAP_ID_CHSV003901SC);

			// 請求書再発行の場合
			if (chsv003901MapCC != null)
			{
				// 再請求登録リスト(必ず1つはセットされる)
				ArrayList reSeikyList = (ArrayList)chsv003901MapCC.get("ECH0051D012CBSMsg1List");

				// 合算フラグ(発行先)
				gsanFlg = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_GSAN_FLG);

				// 発行先の合算フラグが"1"でなければ発行元の合算フラグを見る
				if (!gsanFlg.equals("1"))
				{
					// 合算フラグ(発行元)
					gsanFlg = (String)parentMapCC.get(JCHTushinSvcConstCC.REHAKKO_MOTO_GSAN_FLG);
				}

				// 前受充当金額フラグ(発行元)
				maeukJutoFlg = (String)parentMapCC.get(JCHTushinSvcConstCC.REHAKKO_MOTO_MAEUKE_JUTO_FLG);

				// 窓口の場合、TUSHINSVCPRCCHOHYOCCから債権ステータスを取得
				// (画面のチェックボックスで単行指定された場合のみ債権ステータスがセットされている)
				String saiken_stat = (String)parentMapCC.get("saiken_stat");

				if (!JCRUtilCommon.isNull(saiken_stat))
				{
					if (JACStrConst.SAIKEN_STAT_ICHIBU_KAKNO.equals(saiken_stat))
					{
						ichbuShuno = true;
					}
				}
			}

			// 未納合算が存在する、または前受充当金額が存在する、または一部収納である場合、うち消費税をマスク化する
			// (随時請求登録の場合、いずれの条件も合致しないためマスク化しない)
			if ("1".equals(gsanFlg) || "1".equals(maeukJutoFlg) || ichbuShuno)
			{
				tax = MASK_HN_15;
			}
			else
			{
				tax = JPCUtilCommon.formatNumber((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_STAX_AMNT));
			}

		}
		else
		{
			// 合算フラグ
			gsanFlg = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_GSAN_FLG);
			// 前受充当金額フラグ
			maeukJutoFlg = (String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_MAEUKE_JUTO_FLG);

			// 窓口以外の場合は、一部収納の条件を判定に加えない
			// 未納合算が存在する、または前受充当金額が存在する場合、うち消費税をマスク化する
			if ("1".equals(gsanFlg) || "1".equals(maeukJutoFlg))
			{
				tax = MASK_HN_15;
			}
			else
			{
				tax = JPCUtilCommon.formatNumber((String)parentMapCC.get(JCHTushinSvcConstCC.ECH0051A010_STAX_AMNT));
			}

		}

		return tax;
	}

	/**
	 * 業務パラメータ格納用マップの生成
	 * 
	 * @param inMap 入力マップ
	 * @return 業務パラメータ格納用マップ
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, String> createWkParaMap(HashMap<String, Object> inMap)
	{
		HashMap<String, String> wkParaMap = new HashMap<String, String>();
		
		for (int i = 0; i < COL_EZM0321A010LISTS.length; i++)
		{
			// 業務パラメータ一意明細を取得
			ArrayList<HashMap<String, Object>> msgList = (ArrayList<HashMap<String, Object>>)inMap.get(COL_EZM0321A010LISTS[i]);
			// 取得結果の0件判定
			if (msgList.size() > 0)
			{
				// 一意照会なので1件目のみ取得
				HashMap<String, Object> msgMap = (HashMap<String, Object>)msgList.get(0);
				if(msgMap != null)
				{
					// 業務パラメータ設定値を取得
					String wkParamSetteValue = (String)msgMap.get(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
					// 業務パラメータ格納用マップに追加
					wkParaMap.put(WK_PARA_IDS[i], wkParamSetteValue);
				}
			}
		}
		return wkParaMap;
		
	}
	
	//ANK-4418-00-00 ADD START
	/**
	 * 業務パラメータ格納用マップの生成
	 * 
	 * @param inMap 入力マップ
	 * @return 業務パラメータ格納用マップ
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, String> createWkParaMap2(HashMap<String, Object> inMap)
	{
		HashMap<String, String> wkParaMap = new HashMap<String, String>();
		
		for (int i = 0; i < COL_EZM0321A010LISTM.length; i++)
		{
			// 業務パラメータ一意明細を取得
			ArrayList<HashMap<String, Object>> msgList = (ArrayList<HashMap<String, Object>>)inMap.get(COL_EZM0321A010LISTM[i]);
			// 取得結果の0件判定
			if (null != msgList && msgList.size() > 0)
			{
				// 一意照会なので1件目のみ取得
				HashMap<String, Object> msgMap = (HashMap<String, Object>)msgList.get(0);
				if(msgMap != null)
				{
					// 業務パラメータ設定値を取得
					String wkParamSetteValue = (String)msgMap.get(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
					// 業務パラメータ格納用マップに追加
					wkParaMap.put(WK_PARA_IDM[i], wkParamSetteValue);
				}
			}
		}
		return wkParaMap;
		
	}
	//ANK-4418-00-00 ADD END

// 2014.06.04 OM-2014-0001921 add start
	/**
	 * 住所配列取得処理。
	 * 「第2引数のeditFlgMap = NORMAL」である場合、返却配列の0番目の要素に住所を格納、
	 * それ以外場合、返却配列の1番目の要素に住所を格納し、返却する。
	 * 
	 * @param strAddress 住所文字列
	 * @param editFlgMap 正常サイズか小さいフォントサイズかのフラグも持つmap
	 * @return 住所配列
	 */
	private String[] getAddressArray(String strAddress, HashMap<String, String> editFlgMap)
	{
		String[] addressArray = new String[2];
		addressArray[0] = "";
		addressArray[1] = "";

		String editFlg = editFlgMap.get(EDIT_FLG_KEY);
		
		if (EDIT_FLG_NORMAL.equals(editFlg))
		{
			addressArray[0] = strAddress;
		}
		else
		{
			addressArray[1] = strAddress;
		}

		return addressArray;
	}
// 2014.06.04 OM-2014-0001921 add end
		
	/**
	 * 業務パラメータ格納用マップの生成
	 * 
	 * @param inMap 入力マップ
	 * @return 業務パラメータ格納用マップ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private void setMineoTandoku(SessionHandle handle, IRequestParameterReadWrite param,
			String fixedText, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		HashMap<String, String> wkParaMap = new HashMap<String, String>();
		
		//ANK-4418-00-00 ADD START
		// mineo単独条件フラグ
		boolean mineoSoroFlg = false;
		// mineo単独合計金額
		long mineoSoroTotalAmnt = 0;
		// 初期費用フラグ
		int shokCnt = 0;
		// 初期費用金額
		long shokiAmnt = 0;
		String[] prcKmkList = null;
		
		// 業務パラメータ管理一意照会の実行
		// mineo単独条件の料金項目コードを取得
		execEZM0321A010_2(handle, param, chohyoReqMap);
		// 料金項目コードを取得取得
		ArrayList childList5 = (ArrayList)chohyoReqMap.get(COL_EZM0321A010LIST2);
		HashMap<String, Object> msg5 = (HashMap<String, Object>)childList5.get(0);
		String setValue = (String)msg5.get(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
		if ( null != setValue)
		{
			prcKmkList = setValue.split(CSV);
		}

		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SEIK_UCHI);
		ArrayList childList4 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SEIK_UCHI);
		if ( null != childList4 )
		{
			for(int i = 0; i < childList4.size(); i++)
			{
				HashMap<String, Object> msg4 = (HashMap<String, Object>)childList4.get(i);
				// 料金グループコード
				String prcGrpCd4 = (String)msg4.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
				// 料金項目コード
				String prcKmkCd4 = (String)msg4.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				// 金額
				String amnt4 = (String)msg4.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				
				if(null != prcGrpCd4 && null != prcKmkCd4 && PRC_GROUP_MINEO.equals(prcGrpCd4) && Arrays.asList(prcKmkList).contains(prcKmkCd4))
				{
					//mineo単独の料金項目コードが存在した場合
					mineoSoroFlg = true;
					mineoSoroTotalAmnt+=Long.parseLong(amnt4);
				}
				
			}
		}

		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI);
		ArrayList childList2 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI);
		if ( null != childList2 )
		{
			for(int i = 0; i < childList2.size(); i++)
			{
				HashMap<String, Object> msg2 = (HashMap<String, Object>)childList2.get(i);
				// 料金項目コード
				String prcKmkCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				// 金額
				String amnt2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
				if(null != prcKmkCd2 && SHOKIHIY_OPRCKMKCD.equals(prcKmkCd2) )
				{
					//初期費用等が存在した場合
					shokCnt+=1;
					shokiAmnt+=Long.parseLong(amnt2);
				}
				
			}
		}
		//ANK-4418-00-00 ADD END

		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_MVNO_CHEK);
		ArrayList childList1 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_MVNO_CHEK);
		if(childList1 ==null || childList1.size() == 0)
		{
			//ANK-4418-00-00 ADD START
			// 初期費用等が0件もしくはmineo単独の料金項目コードが存在しない場合、処理を終了
			if (shokCnt == 0 || !mineoSoroFlg)
			{
				//mineo単独でない場合
				parentMapCC.put(JCHTushinSvcConstCC.MINEO_TANDOKU, false);
				return;
			}
			//ANK-4418-00-00 ADD END
		}
		
		//ANK-4418-00-00 DEL START
		///* ◇請求内訳一覧照会サービスインターフェイス */
		//execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI);
		//ArrayList childList2 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI);
		//ANK-4418-00-00 DEL END
		
		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_MVNO_ONLY);
		ArrayList childList3 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_MVNO_ONLY);
		
		//ANK-4418-00-00 MOD START
		//if(childList2 == null || childList3 == null || childList2.size() != childList3.size())
		if(childList2 == null)
		{
			//mineo単独でない場合
			parentMapCC.put(JCHTushinSvcConstCC.MINEO_TANDOKU, false);
			return;
		}

		// 請求内訳リストとmineo単独リストのサイズが一致の場合
		if(childList2.size() == childList3.size())
		{
			for(int i = 0; i < childList2.size(); i++)
			{
				HashMap<String, Object> msg2 = (HashMap<String, Object>)childList2.get(i);
				HashMap<String, Object> msg3 = (HashMap<String, Object>)childList3.get(i);
				// 料金グループコード
				String prcGrpCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
				String prcGrpCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
				// 料金項目コード
				String prcKmkCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				String prcKmkCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				
				if(prcKmkCd2 == null || !prcGrpCd2.equals(prcGrpCd3) || !prcKmkCd2.equals(prcKmkCd3))
				{
					//mineo単独でない場合
					parentMapCC.put(JCHTushinSvcConstCC.MINEO_TANDOKU, false);
					return;
				}
				
			}
		}
		// 請求内訳リストとmineo単独リストのサイズが差分が初期費用分かつ、初期費用とmineo単独合計金額が一致する場合
		else if (childList2.size() - childList3.size() == shokCnt && shokiAmnt == mineoSoroTotalAmnt )
		{
			//mineo単独の場合とみなす
			;
		}
		else
		{
			//mineo単独でない場合
			parentMapCC.put(JCHTushinSvcConstCC.MINEO_TANDOKU, false);
			return;
		}
		//ANK-4418-00-00 MOD END
		

		//mineo単独の場合
		parentMapCC.put(JCHTushinSvcConstCC.MINEO_TANDOKU, true);
		
	}
// ANK-4595-01-00 ADD START
	/**
	 * 業務パラメータ格納用マップの生成(電気単独)
	 * 
	 * @param inMap 入力マップ
	 * @return 業務パラメータ格納用マップ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private void setElectTandoku(SessionHandle handle, IRequestParameterReadWrite param,
			String fixedText, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		HashMap<String, String> wkParaMap = new HashMap<String, String>();
		
		// 電気単独条件フラグ
		boolean electSoroFlg = false;

		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI_ELEC);
		ArrayList childList2 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI_ELEC);
		if ( null != childList2 )
		{
			for(int i = 0; i < childList2.size(); i++)
			{
				HashMap<String, Object> msg2 = (HashMap<String, Object>)childList2.get(i);
				// 料金項目コード
				String prcKmkCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				// 金額
				String amnt2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
		}

		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_ELEC_CHEK);
		ArrayList childList1 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_ELEC_CHEK);
		if(childList1 ==null || childList1.size() == 0)
		{
			// 電気単独の料金項目コードが存在しない場合、処理を終了
			if (!electSoroFlg)
			{
				//電気単独でない場合
				parentMapCC.put(JCHTushinSvcConstCC.ELEC_TANDOKU, false);
				return;
			}
		}
		
		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_ELEC_ONLY);
		ArrayList childList3 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_ELEC_ONLY);
		
		if(childList2 == null)
		{
			//電気単独でない場合
			parentMapCC.put(JCHTushinSvcConstCC.ELEC_TANDOKU, false);
			return;
		}

		// 請求内訳リストと電気単独リストのサイズが一致の場合
		if(childList2.size() == childList3.size())
		{
			for(int i = 0; i < childList2.size(); i++)
			{
				HashMap<String, Object> msg2 = (HashMap<String, Object>)childList2.get(i);
				HashMap<String, Object> msg3 = (HashMap<String, Object>)childList3.get(i);
				// 料金グループコード
				String prcGrpCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
				String prcGrpCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
				// 料金項目コード
				String prcKmkCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				String prcKmkCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				
				if(prcKmkCd2 == null || !prcGrpCd2.equals(prcGrpCd3) || !prcKmkCd2.equals(prcKmkCd3))
				{
					//電気単独でない場合
					parentMapCC.put(JCHTushinSvcConstCC.ELEC_TANDOKU, false);
					return;
				}
				
			}
		}
		else
		{
			//電気単独でない場合
			parentMapCC.put(JCHTushinSvcConstCC.ELEC_TANDOKU, false);
			return;
		}
		//電気単独の場合
		parentMapCC.put(JCHTushinSvcConstCC.ELEC_TANDOKU, true);
		
	}
	/**
	 * 業務パラメータ格納用マップの生成(マンションオーナー)
	 * 
	 * @param inMap 入力マップ
	 * @return 業務パラメータ格納用マップ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private void setMtonTandoku(SessionHandle handle, IRequestParameterReadWrite param,
			String fixedText, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// マンションオーナー条件フラグ
		boolean mtonSoroFlg = false;

		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI_MTON);
		ArrayList childList2 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI_MTON);
		if ( null != childList2 )
		{
			for(int i = 0; i < childList2.size(); i++)
			{
				HashMap<String, Object> msg2 = (HashMap<String, Object>)childList2.get(i);
				// 料金項目コード
				String prcKmkCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				// 金額
				String amnt2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
		}

		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_MTON_CHEK);
		ArrayList childList1 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_MTON_CHEK);
		if(childList1 ==null || childList1.size() == 0)
		{
			// マンションオーナーの料金項目コードが存在しない場合、処理を終了
			if (!mtonSoroFlg)
			{
				//マンションオーナーでない場合
				parentMapCC.put(JCHTushinSvcConstCC.MTON_TANDOKU, false);
				return;
			}
		}
		
		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_MTON_ONLY);
		ArrayList childList3 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_MTON_ONLY);
		
		if(childList2 == null)
		{
			//マンションオーナーでない場合
			parentMapCC.put(JCHTushinSvcConstCC.MTON_TANDOKU, false);
			return;
		}

		// 請求内訳リストと電気単独リストのサイズが一致の場合
		if(childList2.size() == childList3.size())
		{
			for(int i = 0; i < childList2.size(); i++)
			{
				HashMap<String, Object> msg2 = (HashMap<String, Object>)childList2.get(i);
				HashMap<String, Object> msg3 = (HashMap<String, Object>)childList3.get(i);
				// 料金グループコード
				String prcGrpCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
				String prcGrpCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
				// 料金項目コード
				String prcKmkCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				String prcKmkCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				
				if(prcKmkCd2 == null || !prcGrpCd2.equals(prcGrpCd3) || !prcKmkCd2.equals(prcKmkCd3))
				{
					//マンションオーナーでない場合
					parentMapCC.put(JCHTushinSvcConstCC.MTON_TANDOKU, false);
					return;
				}
				
			}
		}
		else
		{
			//マンションオーナーでない場合
			parentMapCC.put(JCHTushinSvcConstCC.MTON_TANDOKU, false);
			return;
		}
		//マンションオーナーの場合
		parentMapCC.put(JCHTushinSvcConstCC.MTON_TANDOKU, true);
		
	}
// ANK-4595-01-00 ADD END
// ANK-4427-00-00 ADD START
	/**
	 * 業務パラメータ格納用マップの生成(NTT卸単独)
	 * 
	 * @param inMap 入力マップ
	 * @return 業務パラメータ格納用マップ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private void setNttoTandoku(SessionHandle handle, IRequestParameterReadWrite param,
			String fixedText, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		HashMap<String, String> wkParaMap = new HashMap<String, String>();
		
		// NTT卸単独条件フラグ
		boolean nttoSoroFlg = false;

		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_8(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI_NTTO);
		ArrayList childList2 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_SKY_U_GKI_NTTO);
		if ( null != childList2 )
		{
			for(int i = 0; i < childList2.size(); i++)
			{
				HashMap<String, Object> msg2 = (HashMap<String, Object>)childList2.get(i);
				// 料金項目コード
				String prcKmkCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				// 金額
				String amnt2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_AMNT);
			}
		}

		
		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_NTT(handle, param, chohyoReqMap, JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_NTTO_ONLY);
		ArrayList childList3 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + JCHTushinSvcConstCC.WORK_KINO_SKBT_CD_NTTO_ONLY);
		
		if(childList2 == null)
		{
			//NTT卸単独でない場合
			parentMapCC.put(JCHTushinSvcConstCC.NTTO_TANDOKU, false);
			return;
		}
		
//#86808 20250312 張 ADD START
		//同一請求契約番号に料金グループコードが"  "でない数をカウントする
		int prcsCd2Cnt = 0;
//#86808 20250312 張 ADD END
		if(childList2.size() == childList3.size())
		{
			for(int i = 0; i < childList2.size(); i++)
			{
				HashMap<String, Object> msg2 = (HashMap<String, Object>)childList2.get(i);
				HashMap<String, Object> msg3 = (HashMap<String, Object>)childList3.get(i);
				// 料金グループコード
				String prcGrpCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
				String prcGrpCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD);
				// 料金コースコード
				String prcsCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
				String prcsCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD);
				// 料金サービスコード
				String prcSvcCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);
				String prcSvcCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD);				
				// 料金項目コード
				String prcKmkCd2 = (String)msg2.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
				String prcKmkCd3 = (String)msg3.get(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD);
//IT1-2025-0000003 20250114 張 MOD START
				//if(prcKmkCd2 == null || !prcGrpCd2.equals(prcGrpCd3) || !prcKmkCd2.equals(prcKmkCd3) || !prcsCd2.equals(prcsCd3) || !prcSvcCd2.equals(prcSvcCd3))
				if(prcKmkCd2 == null || !prcGrpCd2.equals(prcGrpCd3)  || !prcsCd2.equals(prcsCd3) )
//IT1-2025-0000003 20250114 張 MOD END
				{
					//NTT卸単独でない場合
					parentMapCC.put(JCHTushinSvcConstCC.NTTO_TANDOKU, false);
					return;
				}
//#86808 20250312 張 ADD START
				if(!PRCS_CD_KU.equals(prcsCd2) && !"".equals(prcsCd2) && null != prcsCd2  ){
					prcsCd2Cnt++;
				}
//#86808 20250312 張 ADD END	
			}
//#86808 20250312 張 ADD START
			// 同一請求契約番号に料金グループコードが"  "しか持っていない請求はNTT卸単独請求外とする
			if(0 == prcsCd2Cnt){
				//NTT卸単独でない場合
				parentMapCC.put(JCHTushinSvcConstCC.NTTO_TANDOKU, false);
				return;
			}
//#86808 20250312 張 ADD END
		}
		else
		{
			//NTT卸単独でない場合
			parentMapCC.put(JCHTushinSvcConstCC.NTTO_TANDOKU, false);
			return;
		}
		
		//NTT卸単独の場合
		parentMapCC.put(JCHTushinSvcConstCC.NTTO_TANDOKU, true);
		
	}
// ANK-4427-00-00 ADD END
	
	/**
	 * 請求内訳一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0101B010_2(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> chohyoReqMap, String workkinoSbtCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0101B010 = editInMsgECH0101B010_2(param, chohyoReqMap, workkinoSbtCd);
		for (CAANMsg msg : templateECH0101B010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0101B010_2(result, param, workkinoSbtCd);
	}
	/**
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0101B010_2(IRequestParameterReadWrite param, 
			HashMap<String, Object> chohyoReqMap, String workkinoSbtCd) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0101B010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0101B010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0101B010, ECH0101B010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0101B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → 請求内訳一覧照会マップ.ＫＥＹ＿請求番号
		String seikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_NO);
		String motoSeikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
		if (chohyoReqMap == null || motoSeikyNo == null || JACStrConst.KARA_MOJI.equals(motoSeikyNo))
		{
			if (chohyoReqMap == null || seikyNo == null || JACStrConst.KARA_MOJI.equals(seikyNo))
			{
				HashMap<String, Object> inMap2 = (HashMap<String, Object>)param.getData("CHSV004302SC");
				if(inMap2 == null || inMap2.get("seiky_no") == null || JACStrConst.KARA_MOJI.equals((String)inMap2.get("seiky_no")))
				{
					template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_NO);
				} 
				else 
				{
					template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, (String)inMap2.get("seiky_no"));
				}
			}
			else
			{
				template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, seikyNo);
			}
		} 
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, motoSeikyNo);
		}

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求年月 → 請求内訳一覧照会マップ.ＫＥＹ＿請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM);
		if (chohyoReqMap == null || seikyYm == null || JACStrConst.KARA_MOJI.equals(seikyYm))
		{
			template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_YM);
		}
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_YM, seikyYm);
		}

		// "CH" → 請求内訳一覧照会マップ.ＫＥＹ＿システムコード
		template.set(ECH0101B010CBSMsg.KEY_SYS_CD, JACStrConst.SYS_CD_CH);

		// 請求内訳一覧照会マップ.ＫＥＹ＿業務機能識別コード
		template.set(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD, workkinoSbtCd);

		// "1" → 請求内訳一覧照会マップ.料金項目名称種別コード
		template.set(ECH0101B010CBSMsg.KEY_PRC_KMK_NM_SBT_CD, JACStrConst.PRC_KMK_NM_SBT_CD_PRC_NM);

		// 通信サービス料金帳票マップ.請求種別コード → 請求内訳一覧照会マップ.ＫＥＹ＿請求種別コード
		String seikySbtCd = (String)inMap.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_SBT_CD);
		if (inMap == null || seikySbtCd == null || JACStrConst.KARA_MOJI.equals(seikySbtCd))
		{
			template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_SBT_CD);
		}
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_SBT_CD, seikySbtCd);
		}

		templateList.add(template);

		return templateList;
	}
	/**
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0101B010_2(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String workkinoSbtCd) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		ArrayList dataList = null;

		templateArray = parentTemplate.getCAANMsgList(ECH0101B010CBSMsg.ECH0101B010CBSMSG1LIST);

		dataList = (ArrayList)dataMap.get("ECH0101B010CBSMsg1List_"+workkinoSbtCd);

		if (dataList == null)
		{
			dataList = new ArrayList();
		}


		int uwSize = templateArray.length;

		if (templateArray != null)
		{
			for (int i = 0; i < uwSize; i++) 
			{
				CAANMsg childTemplate = templateArray[i];
				if (i >= dataList.size()) 
				{
					dataList.add(new HashMap());
				}
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);

				// 通信サービス料金マップ.請求内訳一覧明細.料金項目コード ← 請求内訳一覧明細.料金項目コード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PRC_KMK_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_KMK_CD));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.料金項目コード ← 請求内訳一覧明細.料金項目コード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PRC_GRP_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_GRP_CD));
				}
				//ANK-4418-00-00 ADD START
				// 通信サービス料金マップ.請求内訳一覧明細.金額 ← 請求内訳一覧明細.金額
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.AMNT)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT, childTemplate.getString(ECH0101B010CBSMsg1List.AMNT));
				}
				//ANK-4418-00-00 ADD END
			}
		}

		dataMap.put("ECH0101B010CBSMsg1List_"+workkinoSbtCd, dataList);

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}


		return param;
	}
	
// v12.01.00 ADD START
	
	/**
	 * 
	 * 未納明細が存在するか否か
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @return true：存在しない、false：存在する
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean isNotMisgGsky(SessionHandle handle,
									IRequestParameterReadWrite param,
									String fixedText,
									HashMap<String, Object> chohyoReqMap) throws Exception {
		
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0101B010_2(handle, param, chohyoReqMap, "MISG_GSKY");
		ArrayList childList1 = (ArrayList)parentMapCC.get("ECH0101B010CBSMsg1List_" + "MISG_GSKY");
		if(childList1 != null && childList1.size() != 0) {
			
			// false：未納が存在する
			return false;
		}
		
		// true：未納が存在しない
		return true;
	}
	
	/**
	 * 
	 * 未納が存在する場合のみ,使用許可.
	 * 
	 * 1.当月合算がmineo単独契約でない場合は,[mineo単独以外]とする.
	 * 
	 * 2.当月合算がmineo単独契約の場合は,未納分契約を遡ってeo契約有無を判断する.
	 *   2-1.未納分全てがmineo単独契約の場合は,[mineo単独]とする.
	 *   2-2.上記以外は,[mineo単独以外]とする.
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception
	 */
	@SuppressWarnings({ "unchecked", "boxing" })
	private void setMisgGskyMineoTandoku(SessionHandle handle,
												IRequestParameterReadWrite param,
												String fixedText,
												HashMap<String, Object> chohyoReqMap) throws Exception {
		
		// リクエストパラメタ取得
		HashMap<String, Object> reqCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// 合算：mineo単独チェック
		setMineoTandoku(handle, param, fixedText, chohyoReqMap);
		
		boolean isMineo = (Boolean)reqCC.get(JCHTushinSvcConstCC.MINEO_TANDOKU);
		
		// 未納：mineo単独チェック
		setMineoTandokuMinoVer(handle, param, fixedText, chohyoReqMap, isMineo ? "1" : "0");
	}
// ANK-4595-01-00 ADD STRAT	
	/**
	 * 
	 * 未納が存在する場合のみ,使用許可.
	 * 
	 * 1.当月合算が電気単独契約でない場合は,[電気単独以外]とする.
	 * 
	 * 2.当月合算が電気単独契約の場合は,未納分契約を遡ってeo契約有無を判断する.
	 *   2-1.未納分全てが電気単独契約の場合は,[電気単独]とする.
	 *   2-2.上記以外は,[電気単独以外]とする.
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception
	 */
	@SuppressWarnings({ "unchecked", "boxing" })
	private void setMisgGskyElectTandoku(SessionHandle handle,
												IRequestParameterReadWrite param,
												String fixedText,
												HashMap<String, Object> chohyoReqMap) throws Exception {
		
		// リクエストパラメタ取得
		HashMap<String, Object> reqCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// 合算：電気単独チェック
		setElectTandoku(handle, param, fixedText, chohyoReqMap);
		
		boolean isElect = (Boolean)reqCC.get(JCHTushinSvcConstCC.ELEC_TANDOKU);
		
		// 未納：電気単独チェック
		setElectTandokuMinoVer(handle, param, fixedText, chohyoReqMap, isElect ? "1" : "0");
	}
	
	/**
	 * 
	 * 未納が存在する場合のみ,使用許可.
	 * 
	 * 1.当月合算がマンションオーナー契約でない場合は,[マンションオーナー以外]とする.
	 * 
	 * 2.当月合算がマンションオーナー契約の場合は,未納分契約を遡ってeo契約有無を判断する.
	 *   2-1.未納分全てがマンションオーナー契約の場合は,[マンションオーナー]とする.
	 *   2-2.上記以外は,[マンションオーナー以外]とする.
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception
	 */
	@SuppressWarnings({ "unchecked", "boxing" })
	private void setMisgGskyMtonTandoku(SessionHandle handle,
												IRequestParameterReadWrite param,
												String fixedText,
												HashMap<String, Object> chohyoReqMap) throws Exception {
		
		// リクエストパラメタ取得
		HashMap<String, Object> reqCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// 合算：マンションオーナーチェック
		setMtonTandoku(handle, param, fixedText, chohyoReqMap);
		
		boolean isMton = (Boolean)reqCC.get(JCHTushinSvcConstCC.MTON_TANDOKU);
		
		// 未納：マンションオーナーチェック
		setMtonTandokuMinoVer(handle, param, fixedText, chohyoReqMap, isMton ? "1" : "0");
	}

// ANK-4595-01-00 ADD END
// ANK-4427-00-00 ADD START
	/**
	 * 
	 * 未納が存在する場合のみ,使用許可.
	 * 
	 * 1.当月合算がNTT卸単独契約でない場合は,[NTT卸単独以外]とする.
	 * 
	 * 2.当月合算がNTT卸単独契約の場合は,未納分契約を遡ってeo契約有無を判断する.
	 *   2-1.未納分全てがNTT卸単独契約の場合は,[NTT卸単独]とする.
	 *   2-2.上記以外は,[NTT卸単独以外]とする.
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception
	 */
	@SuppressWarnings({ "unchecked", "boxing" })
	private void setMisgGskyNttoTandoku(SessionHandle handle,
												IRequestParameterReadWrite param,
												String fixedText,
												HashMap<String, Object> chohyoReqMap) throws Exception {
		
		// リクエストパラメタ取得
		HashMap<String, Object> reqCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// 合算：NTT卸単独チェック
		setNttoTandoku(handle, param, fixedText, chohyoReqMap);
		
		boolean isNtto = (Boolean)reqCC.get(JCHTushinSvcConstCC.NTTO_TANDOKU);
		
		// 未納：NTT卸単独チェック
		setNttoTandokuMinoVer(handle, param, fixedText, chohyoReqMap, isNtto ? "1" : "0");
	}
// ANK-4427-00-00 ADD END
	
	
	/**
	 * 
	 * 未納合算に対して,[mineo単独]か否かを判定し,結果を保持する.
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception 
	 */
	@SuppressWarnings({ "unchecked", "boxing" })
	private void setMineoTandokuMinoVer(SessionHandle handle,
											IRequestParameterReadWrite param,
											String fixedText,
											HashMap<String, Object> chohyoReqMap, String mvnoChkFlg) throws Exception {
		
		final String conMapKey = "setMineoTandokuMinoVer";
		
		HashMap<String, Object> parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0051B060(handle, param, chohyoReqMap, conMapKey, mvnoChkFlg);
		
		ArrayList retList = (ArrayList) parentMapCC.get("ECH0051B060CBSMsg1List_" + conMapKey);
		if(retList == null || retList.size() == 0 || ((HashMap) retList.get(0)).isEmpty()) {
			
			//mineo単独でない場合
			parentMapCC.put(JCHTushinSvcConstCC.MINEO_TANDOKU, false);
			return;
		}
		
		//mineo単独の場合
		parentMapCC.put(JCHTushinSvcConstCC.MINEO_TANDOKU, true);
	}
// ANK-4595-01-00 ADD START 
	/**
	 * 
	 * 未納合算に対して,[電気単独]か否かを判定し,結果を保持する.
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception 
	 */
	@SuppressWarnings({ "unchecked", "boxing" })
	private void setElectTandokuMinoVer(SessionHandle handle,
											IRequestParameterReadWrite param,
											String fixedText,
											HashMap<String, Object> chohyoReqMap, String electChkFlg) throws Exception {
		
		final String conMapKey = "setElectTandokuMinoVer";
		
		HashMap<String, Object> parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0051B080(handle, param, chohyoReqMap, conMapKey, electChkFlg);
		
		ArrayList retList = (ArrayList) parentMapCC.get("ECH0051B080CBSMsg1List_" + conMapKey);
		if(retList == null || retList.size() == 0 || ((HashMap) retList.get(0)).isEmpty()) {
			
			//電気単独でない場合
			parentMapCC.put(JCHTushinSvcConstCC.ELEC_TANDOKU, false);
			return;
		}
		
		//電気単独の場合
		parentMapCC.put(JCHTushinSvcConstCC.ELEC_TANDOKU, true);
	}
	
	/**
	 * 
	 * 未納合算に対して,[マンションオーナー]か否かを判定し,結果を保持する.
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception 
	 */
	@SuppressWarnings({ "unchecked", "boxing" })
	private void setMtonTandokuMinoVer(SessionHandle handle,
											IRequestParameterReadWrite param,
											String fixedText,
											HashMap<String, Object> chohyoReqMap, String mtonChkFlg) throws Exception {
		
		final String conMapKey = "setMtonTandokuMinoVer";
		
		HashMap<String, Object> parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0051B090(handle, param, chohyoReqMap, conMapKey, mtonChkFlg);
		
		ArrayList retList = (ArrayList) parentMapCC.get("ECH0051B090CBSMsg1List_" + conMapKey);
		if(retList == null || retList.size() == 0 || ((HashMap) retList.get(0)).isEmpty()) {
			
			//マンションオーナーでない場合
			parentMapCC.put(JCHTushinSvcConstCC.MTON_TANDOKU, false);
			return;
		}
		
		//マンションオーナーの場合
		parentMapCC.put(JCHTushinSvcConstCC.MTON_TANDOKU, true);
	}
// ANK-4595-01-00 ADD END
// ANK-4427-00-00 ADD START
	/**
	 * 
	 * 未納合算に対して,[NTT卸単独]か否かを判定し,結果を保持する.
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception 
	 */
	@SuppressWarnings({ "unchecked", "boxing" })
	private void setNttoTandokuMinoVer(SessionHandle handle,
											IRequestParameterReadWrite param,
											String fixedText,
											HashMap<String, Object> chohyoReqMap, String nttoChkFlg) throws Exception {
		
		final String conMapKey = "setNttoTandokuMinoVer";
		
		HashMap<String, Object> parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
		
		/* ◇請求内訳一覧照会サービスインターフェイス */
		execECH0051B100(handle, param, chohyoReqMap, conMapKey, nttoChkFlg);
		
		ArrayList retList = (ArrayList) parentMapCC.get("ECH0051B100CBSMsg1List_" + conMapKey);
		if(retList == null || retList.size() == 0 || ((HashMap) retList.get(0)).isEmpty()) {
			
			//NTT卸単独でない場合
			parentMapCC.put(JCHTushinSvcConstCC.NTTO_TANDOKU, false);
			return;
		}
		
		//NTT卸単独の場合
		parentMapCC.put(JCHTushinSvcConstCC.NTTO_TANDOKU, true);
	}
// ANK-4427-00-00 ADD END
	
	/**
	 * 
	 * 請求内訳一覧照会サービスインタフェイスを実行する.
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0051B060(SessionHandle handle,
									IRequestParameterReadWrite param,
									HashMap<String, Object> chohyoReqMap,
									String workkinoSbtCd, String mvnoChkFlg) throws Exception {
		
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0051B060 = editInMsgECH0051B060(param, chohyoReqMap, workkinoSbtCd, mvnoChkFlg);
		
		for (CAANMsg msg : templateECH0051B060) {
			templateList.add(msg);
		}
		
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0051B060(result, param, workkinoSbtCd);
	}
	
	/**
	 * 
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings({ "unchecked", "null", "cast" })
	private ArrayList<CAANMsg> editInMsgECH0051B060(IRequestParameterReadWrite param, 
													HashMap<String, Object> chohyoReqMap,
													@SuppressWarnings("unused") String workkinoSbtCd, 
													String mvnoChkFlg) throws RequestParameterException {
		
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		
		CAANMsg template = new CAANMsg(ECH0051B060CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0051B060CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0051B060, ECH0051B060CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		
		// 機能コード
		template.set(ECH0051B060CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → 請求内訳一覧照会マップ.ＫＥＹ＿請求番号
		String seikyNo     = (String) chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_NO);
		String motoSeikyNo = (String) chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
		
		if (chohyoReqMap == null || motoSeikyNo == null || JACStrConst.KARA_MOJI.equals(motoSeikyNo)) {
			if (chohyoReqMap == null || seikyNo == null || JACStrConst.KARA_MOJI.equals(seikyNo)) {
				
				HashMap<String, Object> inMap2 = (HashMap<String, Object>)param.getData("CHSV004302SC");
				
				if(inMap2 == null || inMap2.get("seiky_no") == null || JACStrConst.KARA_MOJI.equals((String)inMap2.get("seiky_no"))) {
					
					template.setNull(ECH0051B060CBSMsg.KEY_SEIKY_NO);
				} else {
					
					template.set(ECH0051B060CBSMsg.KEY_SEIKY_NO, (String)inMap2.get("seiky_no"));
				}
			} else {
				
				template.set(ECH0051B060CBSMsg.KEY_SEIKY_NO, seikyNo);
			}
		} else {
			
			template.set(ECH0051B060CBSMsg.KEY_SEIKY_NO, motoSeikyNo);
		}

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求年月 → 請求内訳一覧照会マップ.ＫＥＹ＿請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM);
		
		if (chohyoReqMap == null || seikyYm == null || JACStrConst.KARA_MOJI.equals(seikyYm)) {
			template.setNull(ECH0051B060CBSMsg.KEY_SEIKY_YM);
		} else {
			template.set(ECH0051B060CBSMsg.KEY_SEIKY_YM, seikyYm);
		}

		template.set(ECH0051B060CBSMsg.KEY_MVNO_CHK_FLG, mvnoChkFlg);

		templateList.add(template);

		return templateList;
	}
	
	/**
	 * 
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings({ "unchecked", "null", "boxing" })
	private IRequestParameterReadWrite editOutMsgECH0051B060(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																String workkinoSbtCd) throws Exception {

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		if (dataMap == null) {
			
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		ArrayList dataList = null;
		templateArray      = parentTemplate.getCAANMsgList(ECH0051B060CBSMsg.ECH0051B060CBSMSG1LIST);
		dataList           = (ArrayList)dataMap.get("ECH0051B060CBSMsg1List_" + workkinoSbtCd);

		if (dataList == null) {
			dataList = new ArrayList();
		}

		int uwSize = templateArray.length;

		if (templateArray != null) {
			
			for (int i = 0; i < uwSize; i++) {
				
				CAANMsg childTemplate = templateArray[i];
				
				if (i >= dataList.size()) {
					dataList.add(new HashMap());
				}
				
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);
				
				// [mineo単独以外]は保持処理しない.
				boolean isNull = childTemplate.isNull(ECH0051B060CBSMsg1List.MVNO_CHK_FLG) ? true : false;
				if (isNull || "0".equals(childTemplate.getString(ECH0051B060CBSMsg1List.MVNO_CHK_FLG))) {
					continue;
				}
				
				// [mineo単独]時は,ダミーレコードを保持する.
				childMap.put("dm", new String());
			}
		}

		dataMap.put("ECH0051B060CBSMsg1List_"+ workkinoSbtCd, dataList);

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		
		if(errList == null) {
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) {
			throw new Exception();
		}
		return param;
	}
// v12.01.00 ADD END

//ANK-4595-01-00 ADD START
	/**
	 * 
	 * 請求内訳一覧照会サービスインタフェイスを実行する.(電気単独)
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0051B080(SessionHandle handle,
									IRequestParameterReadWrite param,
									HashMap<String, Object> chohyoReqMap,
									String workkinoSbtCd, String electChkFlg) throws Exception {
		
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0051B080 = editInMsgECH0051B080(param, chohyoReqMap, workkinoSbtCd, electChkFlg);
		
		for (CAANMsg msg : templateECH0051B080) {
			templateList.add(msg);
		}
		
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0051B080(result, param, workkinoSbtCd);
	}
	
	/**
	 * 
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ設定処理(電気単独)<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings({ "unchecked", "null", "cast" })
	private ArrayList<CAANMsg> editInMsgECH0051B080(IRequestParameterReadWrite param, 
													HashMap<String, Object> chohyoReqMap,
													@SuppressWarnings("unused") String workkinoSbtCd, 
													String electChkFlg) throws RequestParameterException {
		
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		
		CAANMsg template = new CAANMsg(ECH0051B080CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0051B080CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0051B060, ECH0051B080CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		
		// 機能コード
		template.set(ECH0051B080CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → 請求内訳一覧照会マップ.ＫＥＹ＿請求番号
		String seikyNo     = (String) chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_NO);
		String motoSeikyNo = (String) chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
		
		if (chohyoReqMap == null || motoSeikyNo == null || JACStrConst.KARA_MOJI.equals(motoSeikyNo)) {
			if (chohyoReqMap == null || seikyNo == null || JACStrConst.KARA_MOJI.equals(seikyNo)) {
				
				HashMap<String, Object> inMap2 = (HashMap<String, Object>)param.getData("CHSV004302SC");
				
				if(inMap2 == null || inMap2.get("seiky_no") == null || JACStrConst.KARA_MOJI.equals((String)inMap2.get("seiky_no"))) {
					
					template.setNull(ECH0051B080CBSMsg.KEY_SEIKY_NO);
				} else {
					
					template.set(ECH0051B080CBSMsg.KEY_SEIKY_NO, (String)inMap2.get("seiky_no"));
				}
			} else {
				
				template.set(ECH0051B080CBSMsg.KEY_SEIKY_NO, seikyNo);
			}
		} else {
			
			template.set(ECH0051B080CBSMsg.KEY_SEIKY_NO, motoSeikyNo);
		}

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求年月 → 請求内訳一覧照会マップ.ＫＥＹ＿請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM);
		
		if (chohyoReqMap == null || seikyYm == null || JACStrConst.KARA_MOJI.equals(seikyYm)) {
			template.setNull(ECH0051B080CBSMsg.KEY_SEIKY_YM);
		} else {
			template.set(ECH0051B080CBSMsg.KEY_SEIKY_YM, seikyYm);
		}

		template.set(ECH0051B080CBSMsg.KEY_ELEC_CHK_FLG, electChkFlg);

		templateList.add(template);

		return templateList;
	}
	
	/**
	 * 
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ取得処理(電気単独)<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings({ "unchecked", "null", "boxing" })
	private IRequestParameterReadWrite editOutMsgECH0051B080(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																String workkinoSbtCd) throws Exception {

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		if (dataMap == null) {
			
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		ArrayList dataList = null;
		templateArray      = parentTemplate.getCAANMsgList(ECH0051B080CBSMsg.ECH0051B080CBSMSG1LIST);
		dataList           = (ArrayList)dataMap.get("ECH0051B080CBSMsg1List_" + workkinoSbtCd);

		if (dataList == null) {
			dataList = new ArrayList();
		}

		int uwSize = templateArray.length;

		if (templateArray != null) {
			
			for (int i = 0; i < uwSize; i++) {
				
				CAANMsg childTemplate = templateArray[i];
				
				if (i >= dataList.size()) {
					dataList.add(new HashMap());
				}
				
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);
				
				// [電気単独以外]は保持処理しない.
				boolean isNull = childTemplate.isNull(ECH0051B080CBSMsg1List.ELEC_CHK_FLG) ? true : false;
				if (isNull || "0".equals(childTemplate.getString(ECH0051B080CBSMsg1List.ELEC_CHK_FLG))) {
					continue;
				}
				
				// [電気単独]時は,ダミーレコードを保持する.
				childMap.put("dm", new String());
			}
		}

		dataMap.put("ECH0051B080CBSMsg1List_"+ workkinoSbtCd, dataList);

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		
		if(errList == null) {
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) {
			throw new Exception();
		}
		return param;
	}
	/**
	 * 
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ取得処理(マンションオーナー)<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings({ "unchecked", "null", "boxing" })
	private IRequestParameterReadWrite editOutMsgECH0051B090(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																String workkinoSbtCd) throws Exception {

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		if (dataMap == null) {
			
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		ArrayList dataList = null;
		templateArray      = parentTemplate.getCAANMsgList(ECH0051B090CBSMsg.ECH0051B090CBSMSG1LIST);
		dataList           = (ArrayList)dataMap.get("ECH0051B090CBSMsg1List_" + workkinoSbtCd);

		if (dataList == null) {
			dataList = new ArrayList();
		}

		int uwSize = templateArray.length;

		if (templateArray != null) {
			
			for (int i = 0; i < uwSize; i++) {
				
				CAANMsg childTemplate = templateArray[i];
				
				if (i >= dataList.size()) {
					dataList.add(new HashMap());
				}
				
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);
				
				// [電気単独以外]は保持処理しない.
				boolean isNull = childTemplate.isNull(ECH0051B090CBSMsg1List.MTON_CHK_FLG) ? true : false;
				if (isNull || "0".equals(childTemplate.getString(ECH0051B090CBSMsg1List.MTON_CHK_FLG))) {
					continue;
				}
				
				// [電気単独]時は,ダミーレコードを保持する.
				childMap.put("dm", new String());
			}
		}

		dataMap.put("ECH0051B090CBSMsg1List_"+ workkinoSbtCd, dataList);

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		
		if(errList == null) {
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) {
			throw new Exception();
		}
		return param;
	}
	
	/**
	 * 
	 * 請求内訳一覧照会サービスインタフェイスを実行する.(マンションオーナー)
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0051B090(SessionHandle handle,
									IRequestParameterReadWrite param,
									HashMap<String, Object> chohyoReqMap,
									String workkinoSbtCd, String mtonChkFlg) throws Exception {
		
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0051B090 = editInMsgECH0051B090(param, chohyoReqMap, workkinoSbtCd, mtonChkFlg);
		
		for (CAANMsg msg : templateECH0051B090) {
			templateList.add(msg);
		}
		
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0051B090(result, param, workkinoSbtCd);
	}
	
	/**
	 * 
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ設定処理(マンションオーナー)<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings({ "unchecked", "null", "cast" })
	private ArrayList<CAANMsg> editInMsgECH0051B090(IRequestParameterReadWrite param, 
													HashMap<String, Object> chohyoReqMap,
													@SuppressWarnings("unused") String workkinoSbtCd, 
													String mtonChkFlg) throws RequestParameterException {
		
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		
		CAANMsg template = new CAANMsg(ECH0051B090CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0051B090CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0051B060, ECH0051B090CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		
		// 機能コード
		template.set(ECH0051B090CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → 請求内訳一覧照会マップ.ＫＥＹ＿請求番号
		String seikyNo     = (String) chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_NO);
		String motoSeikyNo = (String) chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
		
		if (chohyoReqMap == null || motoSeikyNo == null || JACStrConst.KARA_MOJI.equals(motoSeikyNo)) {
			if (chohyoReqMap == null || seikyNo == null || JACStrConst.KARA_MOJI.equals(seikyNo)) {
				
				HashMap<String, Object> inMap2 = (HashMap<String, Object>)param.getData("CHSV004302SC");
				
				if(inMap2 == null || inMap2.get("seiky_no") == null || JACStrConst.KARA_MOJI.equals((String)inMap2.get("seiky_no"))) {
					
					template.setNull(ECH0051B090CBSMsg.KEY_SEIKY_NO);
				} else {
					
					template.set(ECH0051B090CBSMsg.KEY_SEIKY_NO, (String)inMap2.get("seiky_no"));
				}
			} else {
				
				template.set(ECH0051B090CBSMsg.KEY_SEIKY_NO, seikyNo);
			}
		} else {
			
			template.set(ECH0051B090CBSMsg.KEY_SEIKY_NO, motoSeikyNo);
		}

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求年月 → 請求内訳一覧照会マップ.ＫＥＹ＿請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM);
		
		if (chohyoReqMap == null || seikyYm == null || JACStrConst.KARA_MOJI.equals(seikyYm)) {
			template.setNull(ECH0051B090CBSMsg.KEY_SEIKY_YM);
		} else {
			template.set(ECH0051B090CBSMsg.KEY_SEIKY_YM, seikyYm);
		}

		template.set(ECH0051B090CBSMsg.KEY_MTON_CHK_FLG, mtonChkFlg);

		templateList.add(template);

		return templateList;
	}
// ANK-4595-01-00 ADD END	
// ANK-4427-00-00 ADD START
	/**
	 * 
	 * 請求内訳一覧照会サービスインタフェイスを実行する.(NTT卸単独)
	 * 
	 * @param  handle
	 * @param  param
	 * @param  fixedText
	 * @param  chohyoReqMap
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0051B100(SessionHandle handle,
									IRequestParameterReadWrite param,
									HashMap<String, Object> chohyoReqMap,
									String workkinoSbtCd, String nttoChkFlg) throws Exception {
		
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0051B100 = editInMsgECH0051B100(param, chohyoReqMap, workkinoSbtCd, nttoChkFlg);
		
		for (CAANMsg msg : templateECH0051B100) {
			templateList.add(msg);
		}
		
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0051B100(result, param, workkinoSbtCd);
	}
	
	/**
	 * 
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ設定処理(NTT卸単独)<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings({ "unchecked", "null", "cast" })
	private ArrayList<CAANMsg> editInMsgECH0051B100(IRequestParameterReadWrite param, 
													HashMap<String, Object> chohyoReqMap,
													@SuppressWarnings("unused") String workkinoSbtCd, 
													String nttoChkFlg) throws RequestParameterException {
		
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		
		CAANMsg template = new CAANMsg(ECH0051B100CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0051B100CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0051B060, ECH0051B100CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		
		// 機能コード
		template.set(ECH0051B100CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → 請求内訳一覧照会マップ.ＫＥＹ＿請求番号
		String seikyNo     = (String) chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_NO);
		String motoSeikyNo = (String) chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
		
		if (chohyoReqMap == null || motoSeikyNo == null || JACStrConst.KARA_MOJI.equals(motoSeikyNo)) {
			if (chohyoReqMap == null || seikyNo == null || JACStrConst.KARA_MOJI.equals(seikyNo)) {
				
				HashMap<String, Object> inMap2 = (HashMap<String, Object>)param.getData("CHSV004302SC");
				
				if(inMap2 == null || inMap2.get("seiky_no") == null || JACStrConst.KARA_MOJI.equals((String)inMap2.get("seiky_no"))) {
					
					template.setNull(ECH0051B100CBSMsg.KEY_SEIKY_NO);
				} else {
					
					template.set(ECH0051B100CBSMsg.KEY_SEIKY_NO, (String)inMap2.get("seiky_no"));
				}
			} else {
				
				template.set(ECH0051B100CBSMsg.KEY_SEIKY_NO, seikyNo);
			}
		} else {
			
			template.set(ECH0051B100CBSMsg.KEY_SEIKY_NO, motoSeikyNo);
		}

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求年月 → 請求内訳一覧照会マップ.ＫＥＹ＿請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM);
		
		if (chohyoReqMap == null || seikyYm == null || JACStrConst.KARA_MOJI.equals(seikyYm)) {
			template.setNull(ECH0051B100CBSMsg.KEY_SEIKY_YM);
		} else {
			template.set(ECH0051B100CBSMsg.KEY_SEIKY_YM, seikyYm);
		}

		template.set(ECH0051B100CBSMsg.KEY_NTTO_CHK_FLG, nttoChkFlg);

		templateList.add(template);

		return templateList;
	}
	
	/**
	 * 
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ取得処理(NTT卸単独)<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings({ "unchecked", "null", "boxing" })
	private IRequestParameterReadWrite editOutMsgECH0051B100(Map<?, ?> msgList,
																IRequestParameterReadWrite param,
																String workkinoSbtCd) throws Exception {

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		if (dataMap == null) {
			
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		ArrayList dataList = null;
		templateArray      = parentTemplate.getCAANMsgList(ECH0051B100CBSMsg.ECH0051B100CBSMSG1LIST);
		dataList           = (ArrayList)dataMap.get("ECH0051B100CBSMsg1List_" + workkinoSbtCd);

		if (dataList == null) {
			dataList = new ArrayList();
		}

		int uwSize = templateArray.length;

		if (templateArray != null) {
			
			for (int i = 0; i < uwSize; i++) {
				
				CAANMsg childTemplate = templateArray[i];
				
				if (i >= dataList.size()) {
					dataList.add(new HashMap());
				}
				
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);
				
				// [NTT卸単独以外]は保持処理しない.
				boolean isNull = childTemplate.isNull(ECH0051B100CBSMsg1List.NTTO_CHK_FLG) ? true : false;
				if (isNull || "0".equals(childTemplate.getString(ECH0051B100CBSMsg1List.NTTO_CHK_FLG))) {
					continue;
				}
				
				// [NTT卸単独]時は,ダミーレコードを保持する.
				childMap.put("dm", new String());
			}
		}

		dataMap.put("ECH0051B100CBSMsg1List_"+ workkinoSbtCd, dataList);

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		
		if(errList == null) {
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) {
			throw new Exception();
		}
		return param;
	}
// ANK-4427-00-00 ADD END
	// ANK-3838-00-00 ADD START
	/**
	 * 
	 * 処理対象の文字列の長さが指定した文字列数より長い場合、指定した文字列の長さに切り取った文字列を返却する。
	 * 切り取り方は文字列の右から指定した文字数だけ切り出す。
	 * 
	 * @param trgetStr 対象文字列
	 * @param strCutCnt 切り出しする文字数(右端からカウントする)
	 * @return editStr 編集文字列(右端から指定文字数分切り出した文字列)
	 * @throws Exception
	 */
	private String editStr(String tergetStr, int strCutCnt)
	{
		// 対象文字列がnullまたは空文字の場合
		if (tergetStr == null || "".equals(tergetStr))
		{
			// 編集文字列を""(空文字)として返却する
			return "";
		}
		
		// 対象文字列の長さを取得
		int tergetStrLength = tergetStr.length();
		
		// 切り出しする文字数が"0"以下の場合
		if (strCutCnt <= 0)
		{
			// 編集文字列を""(空文字)として返却する
			return "";
		}
		
		// 対象文字列の長さが切り出しする文字数より大きくなる場合
		if (tergetStrLength > strCutCnt)
		{
			return tergetStr.substring(tergetStrLength - strCutCnt);
		}
		// 対象文字列の長さが切り出しする文字数以下となる場合
		else
		{
			// 編集文字列に対象文字列を設定して返却する(編集なし)
			return tergetStr;
		}
	}
	// ANK-3838-00-00 ADD END
// ANK-4475-00-00 ADD START
	/**
	 * マップから指定されたリスト項目名の値を取得します。 <br>
	 * 
	 * @param param
	 *            リクエストパラメータ
	 * @param key
	 *            リスト項目名
	 * @return マップ項目値
	 * @throws RequestParameterException
	 *             パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<HashMap<String, Object>> getMapListItem(IRequestParameterReadWrite param, String key) throws RequestParameterException {
		HashMap<String, Object> inMap = (HashMap<String, Object>) param.getData(MAP_ID);
		return (ArrayList<HashMap<String, Object>>) inMap.get(key);
	}
// ANK-4475-00-00 ADD END
	
	//ANK-4468-00-00 ADD START
	/**
	 * シンプルプラングループ計変更情報取得
	 * 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @throws Exception 
	 */
	public void getChangeGroupKei(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		JCHGetChangeGroupKeiInfCC changeGroupKeiCC = new JCHGetChangeGroupKeiInfCC();

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID_GETCHANGEGROUPKEIINFCC);

		if (inMap == null)
		{
			inMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID_GETCHANGEGROUPKEIINFCC, inMap);
		}
		
		//ANK-4468-00-01 ADD START
		inMap.put("func_code", JPCModelConstant.FUNC_CD_1);
		//ANK-4468-00-01 ADD END
		
		// ANK-4427-10-00 ADD START
		HashMap<String, Object> TUSHINSVCPRCCHOHYOCCMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 請求年月
		String seikyYm = (String)TUSHINSVCPRCCHOHYOCCMap.get("key_seiky_ym");
		inMap.put("key_seiky_ym", seikyYm);
		// ANK-4427-10-00 ADD END
		changeGroupKeiCC.getChangeGroupKeiInf(handle, param, MAP_CC_ID_GETCHANGEGROUPKEIINFCC);
		
		
	}
	
	/**
	 * シンプルプランID計業務パラメータ設定値取得
	 * 
	 * @param param
	 * @return simpleWorkParamSetteValueList
	 */
	private ArrayList<String> simpleIdWorkParamValueList(IRequestParameterReadWrite param) throws Exception
		{
			HashMap<String, Object> simpleIdWorkParamValue = (HashMap<String, Object>) param.getData(MAP_CC_ID_GETCHANGEGROUPKEIINFCC);
			ArrayList<HashMap<String, Object>> simpleIdList = (ArrayList<HashMap<String, Object>>) simpleIdWorkParamValue.get("EZM0321B010CBSMsg1List_1");
			int listSize1 = simpleIdList.size();
			ArrayList<String>  simpleWorkParamSetteValueList = new ArrayList<String>();
			
			for (int i = 0; i < listSize1; i++)
			{
				HashMap childMap1 = (HashMap)simpleIdList.get(i);
				
				if (childMap1 != null)
				{
					// ID計の業務パラメータ設定値取得
					simpleWorkParamSetteValueList.add((String)childMap1.get("work_param_sette_value"));
				}
			}
			return simpleWorkParamSetteValueList;
		}
		
		
	/**
	 * シンプルプラン料金グループ計業務パラメータ設定値取得
	 * 
	 * @param param
	 * @return simpleGroupKeiWorkParamSetteValueList
	 */
	private ArrayList<String> simpleGroupKeiWorkParamValueList(IRequestParameterReadWrite param) throws Exception
		{
			HashMap<String, Object> simpleGroupKeiWorkParamValue = (HashMap<String, Object>) param.getData(MAP_CC_ID_GETCHANGEGROUPKEIINFCC);
			ArrayList<HashMap<String, Object>> simpleGroupKeiList = (ArrayList<HashMap<String, Object>>) simpleGroupKeiWorkParamValue.get("EZM0321B010CBSMsg1List_2");
			int listSize2 = simpleGroupKeiList.size();
			ArrayList<String>  simpleGroupKeiWorkParamSetteValueList = new ArrayList<String>();
			for (int i = 0; i < listSize2; i++)
			{
				HashMap childMap2 = (HashMap)simpleGroupKeiList.get(i);
				
				if (childMap2 != null)
				{
					// 料金グループ計の業務パラメータ設定値取得
					simpleGroupKeiWorkParamSetteValueList.add((String)childMap2.get("work_param_sette_value"));
				}
			}
			return simpleGroupKeiWorkParamSetteValueList;
		}

	/**
	 * シンプルプラン料金項目名称取得
	 * 
	 * @param param
	 * @return simpleRePrcKmkNm
	 */
	private String simplePlanRePrcKmkNm(IRequestParameterReadWrite param) throws Exception
		{
			HashMap<String, Object> simplePrcKmkNm = (HashMap<String, Object>) param.getData(MAP_CC_ID_GETCHANGEGROUPKEIINFCC);
			ArrayList<HashMap<String, Object>> simplePrcKmkNmList = (ArrayList<HashMap<String, Object>>) simplePrcKmkNm.get("ECH0391A010CBSMsg1List");
			String simpleRePrcKmkNm = "";
			if(!JKKStringUtil.isNullEmpty(simplePrcKmkNmList))
			{
				Object objectPrcKmkNm = simplePrcKmkNmList.get(0).get("prc_kmk_nm");
				if(objectPrcKmkNm != null)
				{
					//料金項目名称取得
					simpleRePrcKmkNm = objectPrcKmkNm.toString();
				}
			}
			return simpleRePrcKmkNm;
		}
	//ANK-4468-00-00 ADD END
	//ANK-4427-00-00 ADD START
	/**
	 * 請求内訳一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0101B010_8(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> chohyoReqMap, String workkinoSbtCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);
		

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0101B010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0101B010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0101B010, ECH0101B010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0101B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_8);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → 請求内訳一覧照会マップ.ＫＥＹ＿請求番号
		String seikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_NO);
		String motoSeikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
		if (chohyoReqMap == null || motoSeikyNo == null || JACStrConst.KARA_MOJI.equals(motoSeikyNo))
		{
			if (chohyoReqMap == null || seikyNo == null || JACStrConst.KARA_MOJI.equals(seikyNo))
			{
				HashMap<String, Object> inMap2 = (HashMap<String, Object>)param.getData("CHSV004302SC");
				if(inMap2 == null || inMap2.get("seiky_no") == null || JACStrConst.KARA_MOJI.equals((String)inMap2.get("seiky_no")))
				{
					template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_NO);
				} 
				else 
				{
					template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, (String)inMap2.get("seiky_no"));
				}
			}
			else
			{
				template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, seikyNo);
			}
		} 
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, motoSeikyNo);
		}

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求年月 → 請求内訳一覧照会マップ.ＫＥＹ＿請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM);
		if (chohyoReqMap == null || seikyYm == null || JACStrConst.KARA_MOJI.equals(seikyYm))
		{
			template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_YM);
		}
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_YM, seikyYm);
		}

		// "CH" → 請求内訳一覧照会マップ.ＫＥＹ＿システムコード
		template.set(ECH0101B010CBSMsg.KEY_SYS_CD, JACStrConst.SYS_CD_CH);

		// 請求内訳一覧照会マップ.ＫＥＹ＿業務機能識別コード
		template.set(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD, workkinoSbtCd);

		// "1" → 請求内訳一覧照会マップ.料金項目名称種別コード
		template.set(ECH0101B010CBSMsg.KEY_PRC_KMK_NM_SBT_CD, JACStrConst.PRC_KMK_NM_SBT_CD_PRC_NM);

		// 通信サービス料金帳票マップ.請求種別コード → 請求内訳一覧照会マップ.ＫＥＹ＿請求種別コード
		String seikySbtCd = (String)inMap.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_SBT_CD);
		if (inMap == null || seikySbtCd == null || JACStrConst.KARA_MOJI.equals(seikySbtCd))
		{
			template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_SBT_CD);
		}
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_SBT_CD, seikySbtCd);
		}

		templateList.add(template);
	
		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList2 = new ArrayList<CAANMsg>();
		
		for (CAANMsg msg : templateList)
		{
			templateList2.add(msg);
		}
		CAANMsg[] templates = templateList2.toArray(new CAANMsg[templateList2.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0101B010_8(result, param, workkinoSbtCd);
	}
	
	/**
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0101B010_8(Map<?, ?> msgList,
			IRequestParameterReadWrite param, String workkinoSbtCd) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		ArrayList dataList = null;

		templateArray = parentTemplate.getCAANMsgList(ECH0101B010CBSMsg.ECH0101B010CBSMSG1LIST);

		dataList = (ArrayList)dataMap.get("ECH0101B010CBSMsg1List_"+workkinoSbtCd);

		if (dataList == null)
		{
			dataList = new ArrayList();
		}


		int uwSize = templateArray.length;

		if (templateArray != null)
		{
			for (int i = 0; i < uwSize; i++) 
			{
				CAANMsg childTemplate = templateArray[i];
				if (i >= dataList.size()) 
				{
					dataList.add(new HashMap());
				}
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);

				// 通信サービス料金マップ.請求内訳一覧明細.料金項目コード ← 請求内訳一覧明細.料金項目コード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PRC_KMK_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_KMK_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_KMK_CD));
				}
				// 通信サービス料金マップ.請求内訳一覧明細.料金項目コード ← 請求内訳一覧明細.料金項目コード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PRC_GRP_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_GRP_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_GRP_CD));
				}
				
				// 通信サービス料金マップ.請求内訳一覧明細.金額 ← 請求内訳一覧明細.金額
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.AMNT)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_AMNT, childTemplate.getString(ECH0101B010CBSMsg1List.AMNT));
				}
				
				//通信サービス料金マップ.料金コースコード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PCRS_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PCRS_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PCRS_CD));
				}
				
				//通信サービス料金マップ.料金サービスコード
				if (childTemplate.isNull(ECH0101B010CBSMsg1List.PRC_SVC_CD)) 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD, new String());
				}
				else 
				{
					childMap.put(JCHTushinSvcConstCC.ECH0101B010_PRC_SVC_CD, childTemplate.getString(ECH0101B010CBSMsg1List.PRC_SVC_CD));
				}
				
			}
		}

		dataMap.put("ECH0101B010CBSMsg1List_"+workkinoSbtCd, dataList);

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}


		return param;
	}
	

	/**
	 * 請求内訳一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0101B010_NTT(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> chohyoReqMap, String workkinoSbtCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		//IT1-2025-0000003 20250114 張 MOD START
		//ArrayList<CAANMsg> templateECH0101B010 = editInMsgECH0101B010_2(param, chohyoReqMap, workkinoSbtCd);
		ArrayList<CAANMsg> templateECH0101B010 = editInMsgECH0101B010_9(param, chohyoReqMap, workkinoSbtCd);
		//IT1-2025-0000003 20250114 張 MOD END
		for (CAANMsg msg : templateECH0101B010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0101B010_8(result, param, workkinoSbtCd);
	}
	//ANK-4427-00-00 ADD END
	
//IT1-2025-0000003 20250114 張 ADD START
	/**
	 * 請求内訳一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0101B010_9(IRequestParameterReadWrite param, 
			HashMap<String, Object> chohyoReqMap, String workkinoSbtCd) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0101B010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				ECH0101B010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0101B010, ECH0101B010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0101B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_9);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求番号 → 請求内訳一覧照会マップ.ＫＥＹ＿請求番号
		String seikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_NO);
		String motoSeikyNo = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0051A010_KEY_REHAKKO_MOTO_SEIKY_NO);
		if (chohyoReqMap == null || motoSeikyNo == null || JACStrConst.KARA_MOJI.equals(motoSeikyNo))
		{
			if (chohyoReqMap == null || seikyNo == null || JACStrConst.KARA_MOJI.equals(seikyNo))
			{
				HashMap<String, Object> inMap2 = (HashMap<String, Object>)param.getData("CHSV004302SC");
				if(inMap2 == null || inMap2.get("seiky_no") == null || JACStrConst.KARA_MOJI.equals((String)inMap2.get("seiky_no")))
				{
					template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_NO);
				} 
				else 
				{
					template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, (String)inMap2.get("seiky_no"));
				}
			}
			else
			{
				template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, seikyNo);
			}
		} 
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_NO, motoSeikyNo);
		}

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求年月 → 請求内訳一覧照会マップ.ＫＥＹ＿請求年月
		String seikyYm = (String)chohyoReqMap.get(JCHTushinSvcConstCC.ECH0101B010_KEY_SEIKY_YM);
		if (chohyoReqMap == null || seikyYm == null || JACStrConst.KARA_MOJI.equals(seikyYm))
		{
			template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_YM);
		}
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_YM, seikyYm);
		}

		// "CH" → 請求内訳一覧照会マップ.ＫＥＹ＿システムコード
		template.set(ECH0101B010CBSMsg.KEY_SYS_CD, JACStrConst.SYS_CD_CH);

		// 請求内訳一覧照会マップ.ＫＥＹ＿業務機能識別コード
		template.set(ECH0101B010CBSMsg.KEY_WORK_KINO_SKBT_CD, workkinoSbtCd);

		// "1" → 請求内訳一覧照会マップ.料金項目名称種別コード
		template.set(ECH0101B010CBSMsg.KEY_PRC_KMK_NM_SBT_CD, JACStrConst.PRC_KMK_NM_SBT_CD_PRC_NM);

		// 通信サービス料金帳票マップ.請求種別コード → 請求内訳一覧照会マップ.ＫＥＹ＿請求種別コード
		String seikySbtCd = (String)inMap.get(JCHTushinSvcConstCC.ECH0051A010_SEIKY_SBT_CD);
		if (inMap == null || seikySbtCd == null || JACStrConst.KARA_MOJI.equals(seikySbtCd))
		{
			template.setNull(ECH0101B010CBSMsg.KEY_SEIKY_SBT_CD);
		}
		else
		{
			template.set(ECH0101B010CBSMsg.KEY_SEIKY_SBT_CD, seikySbtCd);
		}

		templateList.add(template);

		return templateList;
	}
//IT1-2025-0000003 20250114 張 ADD END

}