/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JFUCommonUtil
*	ソースファイル名：JFUCommonUtil.java
*	作成者			：富士通
*	日付			：2010年08月27日
*＜機能概要＞
*	フロント受付用共通部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2010/08/27	FJ）西川	新規作成
*	v5.00		2013/01/31	FJ）谷本	ANK-1416-00-00_11月末対応
*   v5.00       2013/02/14  FJ）文元   【ST2-2013-0000685】日付の加減算を追加
*   v15.00      2015/05/21  FJ)横山    【ANK-2480-00-00】新電力対応 暗号化ロジックを転記
*   v17.00      2015/10/19  FJ）横山   【OM-2015-0002581】口座振替対応の修正
*   v29.00      2017/03/30  FJ）張本   【ANK-3147-00-00】OPMS工期変更理由のWeb工程進捗への反映
*   v67.00      2023/07/03  FJ) 美濃原 【ANK-4415-00-00】口振請求及びWeb申込システム移行 STEP1
*
**********************************************************************/
package eo.common.util;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Map;
import java.util.Random;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;

import com.fujitsu.futurity.model.common.check.DatetimeCheck;

import eo.common.constant.JFUStrConst;

/**
 * フロント受付用共通部品
 * <br>
 * @author 富士通
 */
public class JFUCommonUtil extends JPCUtilCommon
{

	/** 文字列変換処理 置換対象文字 */
	private static final String REGEX_VU = "ウ(゛|”|“)";

	/** 文字列変換処理 ひらがな（全角）う゛ */
	private static final String HIRA_VU = "う゛";

	/** 文字列変換処理 カタカナ（全角）ヴ */
	private static final String KATA_VU = "ヴ";

	/** カタカナ（全角）ァ */
	private static final char KATA_A = 'ァ';

	/** カタカナ（全角）ロ */
	private static final char KATA_RO = 'ロ';

	/** 文字列変換処理 カタカナ（全角）ワ */
	private static final char KATA_WA = 'ワ';

	/** 文字列変換処理 カタカナ（全角）ヲ */
	private static final char KATA_WO = 'ヲ';

	/** 文字列変換処理 カタカナ（全角）ヶ */
	private static final char KATA_KE = 'ヶ';

	/** 
	 * 半角'a'
	 */
	private static final char HANKAKU_ko_a = 'a';

	/** 
	 * 全角'ａ' 
	 */
	private static final char ZENKAKU_ko_a = 'ａ';

	/** 
	 * 半角'z'
	 */
	private static final char HANKAKU_ko_z = 'z';

	/** 
	 * 全角'ａ' 
	 */
	private static final char ZENKAKU_ko_z = 'ｚ';

	/** 
	 * 半角'A'
	 */
	private static final char HANKAKU_A = 'A';

	/** 
	 * 全角'Ａ' 
	 */
	private static final char ZENKAKU_A = 'Ａ';

	/** 
	 * 半角'Z'
	 */
	private static final char HANKAKU_Z= 'Z';

	/** 
	 * 全角'Ｚ' 
	 */
	private static final char ZENKAKU_Z = 'Ｚ';

	/** 
	 * 半角'0'
	 */
	private static final char HANKAKU_ZERO = '0';

	/** 
	 * 全角'０'
	 */
	private static final char ZENKAKU_ZERO = '０';

	/** 
	 * 半角'9'
	 */
	private static final char HANKAKU_NINE= '9';

	/** 
	 * 全角'０'
	 */
	private static final char ZENKAKU_NINE = '９';

	/** 
	 * 全角'　'
	 */
	private static final char ZENKAKU_SPACE = '　';

	/** 
	 * 半角' '
	 */
	private static final char HANKAKU_SPACE= ' ';

	/** 
	 * 全角'￣'
	 */
	private static final char ZENKAKU_OVER= '￣';

	/** 
	 * 全角'‐'
	 */
	private static final char ZENKAKU_HAIHUN= '‐';

	// ANK-2480-00-00_新電力対応 2015/05/21 add start
    private static final String ENCRYPT_FORMAT = "Blowfish"; // 暗号化方式
    private static final String TRUE_KEY = "ENCRYPT_KEY";
    private static final int STRING_SIZE = 2; // 1byteのデータから生成される文字数
	// ANK-2480-00-00_新電力対応 2015/05/21 add end
	
	/**
	 * null値変換処理
	 * <br>
	 * @param arg1 引数１
	 * @param arg2 引数２
	 * @return 引数１がnullの場合は引数２、null以外の場合は引数１を返却する。
	 */
	public static String nvl(String arg1, String arg2)
	{
		return null == arg1 ? arg2 : arg1;
	}

	/**
	 * Map項目値取得処理
	 * <br>
	 * @param parmMap Mapオブジェクト
	 * @param key 取得対象の項目名
	 * @param value 指定値
	 * @return 取得値がnullの場合は指定値、null以外の場合は取得値を返却する。
	 */
	public static String getMapValueString(Map<Object, Object> parmMap, String key, String value)
	{
		Object obj = null;
		if (null != parmMap)
		{
			obj = parmMap.get(key);
		}
		return null == obj ? value : obj.toString();
	}

	/**
	 * 指定日付(翌月月初)取得処理
	 * 指定した年月の翌月月初の年月日を返却します。
	 * <br>
	 * @param arg 年月(yyyyMM) or 年月日(yyyyMMdd)
	 * @return String 翌月月初日付(yyyyMMdd)
	 * @throws ParseException 
	 */
	public static String getBeginOfNextMonthDate(String arg) throws ParseException
	{
		if (arg == null)
		{
			return null;
		}
		
		return JFUCommonUtil.addMonth(arg.substring(0, 6) + "01", 1);
	}

	/**
	 * 指定日付(月末)取得処理
	 * 指定した年月の月末日の年月日を返却します。
	 * <br>
	 * @param arg 年月(yyyyMM) or 年月日(yyyyMMdd)
	 * @return String 月末日付(yyyyMMdd)
	 */
	public static String getEndOfMonthDate(String arg)
	{
		if (arg == null)
		{
			return null;
		}
		
		return arg.substring(0, 6) + JFUCommonUtil.getEndOfMonth(arg);
	}
	
	/**
	 * 指定日付(月末加減算)取得処理
	 * 指定した年月の月末日を加減算した年月日を返却します。
	 * <br>
	 * @param arg0 年月(yyyyMM) or 年月日(yyyyMMdd)
	 * @param arg1 加算する日数
	 * @return String 月末(加減算)日付(yyyyMMdd)
	 */
	public static String getEndOfMonthAddDate(String arg0, int arg1)
	{
		if (arg0 == null)
		{
			return null;
		}
		
		return JFUCommonUtil.addDay(arg0.substring(0, 6) + JFUCommonUtil.getEndOfMonth(arg0), arg1);
	}

	/**
	 * 日付の加減算処理
	 * 日付の加減算を行います。
	 * <br>
	 * @param arg0 加算対象の日付(yyyyMMddまたはyyyyMMddHHmmss)
	 * @param arg1 加算する日数
	 * @return String 加減算した日付
	 */
	public static String addSubtractDay(String arg0, int arg1) 
	{
		if (arg0 == null)
		{
			return null;
		}
		
		return JFUCommonUtil.addDay(arg0, arg1);
	}
	
	/**
	 * オブジェクトに値が設定されているか判定します。
	 * <br>
	 * @param arg0 判定するオブジェクト
	 * @return オブジェクトに値が設定されていない場合はtrue
	 */
	public static boolean isNull(Object arg0)
	{
		return JPCCommonUtil.isNull(arg0);
	}
	
	/**
	 * 文字列を「"」で囲みます。
	 * <br> 
	 * @param arg0 対象文字列
	 * @return "対象文字列"
	 */
	public static String getStringToDblQuote(String arg0)
	{
		StringBuffer sb = new StringBuffer();

		sb.append(JFUStrConst.S_DUBLLEQ);
		sb.append(arg0);
		sb.append(JFUStrConst.S_DUBLLEQ);

		return sb.toString();
	}

	/**
	 * 文字列変換処理（ひらがな（全角）→カタカナ（全角））(ヴ対応版）
	 * 「う"（濁点）」、「う“（二重引用符 始）」、「う”（二重引用符 終）」を「ヴ」に変換します。
	 * <br>
	 * @param arg0 変換する文字列
	 * @return String 変換された文字列
	 */
	public static String convFullHiraToFullKataV(String arg0)
	{
		// カタカナに変換
		String kana = JPCUtilCommon.convFullHiraToFullKata(arg0);
		// 置換する
		return kana.replaceAll(REGEX_VU, KATA_VU);
	}

	/**
	 * 文字列変換処理（カタカナ（全角）→ひらがな（全角））(ヴ対応版）
	 * 「ヴ」を「う゛（濁点）」に変換します。
	 * <br>
	 * @param arg0 変換する文字列
	 * @return String 変換された文字列
	 */
	public static String convFullKataToFullHiraV(String arg0)
	{
		// ひらがなに変換
		String hira = JPCUtilCommon.convFullKataToFullHira(arg0);
		// 置換する
		return hira.replaceAll(KATA_VU, HIRA_VU);
	}

	/**
	 * 半角文字内容をすべて全角文字内容に変換
	 * <br>
	 * @param string 変換対象の文字列
	 * @return String 変換された文字列
	 */
	public static String convertToZenkaku(String arg0) 
	{
		if(!JPCConvertString.isNull(arg0)){
			arg0 = arg0.trim();
		}
		if(JPCConvertString.isNull(arg0)) 
		{
			return arg0;
		}

		Boolean knsCheck = true;
		Boolean spaceCheck = false;

		StringBuffer strBuf = new StringBuffer();

		String convBefore = "";
		String convAfter = "";

		// 半角カナ⇒全角カナ
		arg0 = JPCUtilCommon.convHalfToFullByKata(arg0);

		for(int i = 0; i < arg0.length(); i++) 
		{
			char code = arg0.charAt(i);

			// 半角英字大文字⇒全角英字大文字
			if((code >= HANKAKU_A) && (HANKAKU_Z >= code)) 
			{
				strBuf.append((char)(code - HANKAKU_A + ZENKAKU_A));
				spaceCheck = true;
				continue;
			}

			// 半角英字小文字⇒全角英字小文字
			if((code >= HANKAKU_ko_a) && (HANKAKU_ko_z >= code)) 
			{
				strBuf.append((char)(code - HANKAKU_ko_a + ZENKAKU_ko_a));
				spaceCheck = true;
				continue;
			}

			// 半角数字⇒全角数字
			if((code >= HANKAKU_ZERO) && (HANKAKU_NINE >= code)) 
			{
				strBuf.append((char)(code - HANKAKU_ZERO + ZENKAKU_ZERO));
				spaceCheck = true;
				continue;
			}

			// 半角記号⇒全角記号
			convBefore = String.valueOf(code);
			convAfter = toBigKigo(code);
			if(convAfter.equals(ZENKAKU_SPACE)){
			}
			else{
				spaceCheck = true;
			}
			if (!convBefore.equals(convAfter))
			{
				strBuf.append(convAfter);
				continue;
			}

			// 全角カナ、対象文字なら素通し
			if(((code >= KATA_A)&&(KATA_RO >= code)) || (code == KATA_WA)
					|| ((code >= KATA_WO) && (KATA_KE >= code))
					|| (code == ZENKAKU_OVER) || (code == ZENKAKU_HAIHUN))
			{
				strBuf.append((char)(code));
				spaceCheck = true;
			}
			else{
				knsCheck = false;
			}
		}

		if(!knsCheck || !spaceCheck){
			return null;
		}
		else{
			return strBuf.toString();
		}
	}

	/**
	 * 全角カタカナをすべて半角文字内容に変換（携帯用）
	 * <br>
	 * @param string 変換対象の文字列
	 * @return String 変換された文字列
	 */
	public static String convertToHankakuKt(String arg0) 
	{
		if(JPCConvertString.isNull(arg0)) 
		{
			return arg0;
		}

		StringBuffer strBuf = new StringBuffer();

		// 全角カナ⇒半角カナ
		arg0 = JPCUtilCommon.convFullToHalfByKata(arg0);

		for(int i = 0; i < arg0.length(); i++) 
		{
			char code = arg0.charAt(i);

			// 全角英字大文字⇒半角英字大文字
			if((code >= ZENKAKU_A) && (ZENKAKU_Z >= code)) 
			{
				strBuf.append((char)(code - ZENKAKU_A + HANKAKU_A));
				continue;
			}

			// 全角英字小文字⇒半角英字小文字
			if((code >= ZENKAKU_ko_a) && (ZENKAKU_ko_z >= code)) 
			{
				strBuf.append((char)(code - ZENKAKU_ko_a + HANKAKU_ko_a));
				continue;
			}

			// 全角数字⇒半角数字
			if((code >= ZENKAKU_ZERO) && (ZENKAKU_NINE >= code)) 
			{
				strBuf.append((char)(code - ZENKAKU_ZERO + HANKAKU_ZERO));
				continue;
			}

			// 全角記号⇒半角記号
			strBuf.append(toSmallKigoKt(code));
		}
		return strBuf.toString();
	}

	/**
	 * ひらがな（全角）→カタカナ（半角）に変換
	 * <br>
	 * @param string 変換対象の文字列
	 * @return String 変換された文字列
	 */
	public static String convertFullHiraToHankakuKt(String arg0) 
	{
		if(JPCConvertString.isNull(arg0)) 
		{
			return arg0;
		}

		StringBuffer strBuf = new StringBuffer();

		// ひらがな（全角）→カタカナ（全角）に変換
		arg0 = convFullHiraToFullKataV(arg0);
		// カタカナ（全角）→カタカナ（半角）に変換
		arg0 = JPCConvertString.convFullToHalfByKata(arg0);

		for(int i = 0; i < arg0.length(); i++) 
		{
			char code = arg0.charAt(i);

			// 全角英字大文字⇒半角英字大文字
			if((code >= ZENKAKU_A) && (ZENKAKU_Z >= code)) 
			{
				strBuf.append((char)(code - ZENKAKU_A + HANKAKU_A));
				continue;
			}

			// 全角英字小文字⇒半角英字小文字
			if((code >= ZENKAKU_ko_a) && (ZENKAKU_ko_z >= code)) 
			{
				strBuf.append((char)(code - ZENKAKU_ko_a + HANKAKU_ko_a));
				continue;
			}

			// 全角数字⇒半角数字
			if((code >= ZENKAKU_ZERO) && (ZENKAKU_NINE >= code)) 
			{
				strBuf.append((char)(code - ZENKAKU_ZERO + HANKAKU_ZERO));
				continue;
			}

			// 全角記号⇒半角記号
			strBuf.append(toSmallKigoKt(code));
		}
		return strBuf.toString();
	}

	/**
	 * 半角から全角変換（記号）
	 * <br>
	 * @param code 変換対象の文字列
	 * @return String 変換された文字列
	 */
	private static final String toBigKigo(char code)
	{
		switch(code){
			case ' ' : return "　";
			case '｡' : return "。";
			case ',' : return "，";
			case '.' : return "．";
			case '･' : return "・";
			case ':' : return "：";
			case ';' : return "；";
			case '?' : return "？";
			case '!' : return "！";
			case 'ﾞ' : return "゛";
			case 'ﾟ' : return "゜";
			case '￣' : return "￣";
			case '_' : return "＿";
			case 'ｰ' : return "ー";
			case '‐' : return "‐";
			case '/' : return "／";
			case '|' : return "｜";
			case '`' : return "‘";
			case '\'' : return "’";
			case '\"' : return "”";
			case '(' : return "（";
			case ')' : return "）";
			case '[' : return "［";
			case ']' : return "］";
			case '{' : return "｛";
			case '}' : return "｝";
			case '｢' : return "「";
			case '｣' : return "」";
			case '+' : return "＋";
			case '-' : return "−";
			case '=' : return "＝";
			case '<' : return "＜";
			case '>' : return "＞";
			case '\\' : return "￥";
			case '$' : return "＄";
			case '%' : return "％";
			case '#' : return "＃";
			case '&' : return "＆";
			case '*' : return "＊";
			case '@' : return "＠";

		}
		return String.valueOf(code);
	}

	/**
	 * 全角から半角変換（記号 携帯用）
	 * <br>
	 * @param code 変換対象の文字列
	 * @return String 変換された文字列
	 */
	private static final String toSmallKigoKt(char code)
	{
		switch(code){
			case '−' : return "-";
			case '＃' : return "#";
			case '（' : return "(";
			case '）' : return ")";
			case '，' : return ",";
			case '、' : return "､";
			case '．' : return ".";
			case '。' : return "｡";
			case '／' : return "/";
			case '：' : return ":";
			case '＠' : return "@";
			case '［' : return "[";
			case '］' : return "]";
			case '＿' : return "_";
			case '「' : return "｢";
			case '」' : return "｣";
			case '＞' : return ">";
			case 'ー' : return "ｰ";
			case '　' : return " ";
		}
		return String.valueOf(code);
	}

	 /**
	 * ランダムな英数字の文字列を返却する。
	 * 
	 * <br>
	 * @return ランダムな英数字の文字列
	 */
	public static String createRondomKey()
	{
		String randomKey = Long.toString(System.nanoTime());
		Random rnd = new Random();
		randomKey = rnd.nextInt(10) + randomKey;
		StringBuffer randomKeyBf = new StringBuffer();
		for (int i = 0; i < randomKey.length(); i++)
		{
			String str = String.valueOf(randomKey.charAt(i));
			int j = 0;
			while (i < randomKey.length() - 1)
			{
				if (j == 4)
				{
					break;
				}
				j++;
				i++;
				str += String.valueOf(randomKey.charAt(i));
			}
			randomKeyBf.append(Integer.toHexString(Integer.parseInt(str)));
			int rndNum = rnd.nextInt(26) + 65;
			if (rndNum % 2 == 0)
			{
				randomKeyBf.insert(0, (char)rndNum);
			}
			else
			{
				randomKeyBf.append((char)rndNum);
			}
		}
		randomKey = randomKeyBf.toString();
		return randomKey.length() > 14 ? randomKey.substring(0, 15) : randomKey;
	}
	
	// ANK-2480-00-00_新電力対応 2015/05/21 add start
    
    /** 
     * 暗号化処理を行います。（キーに渡された復号化した後）
     * @param  String key
     * @param  String text
     * @throws  IllegalBlockSizeException,InvalidKeyException,NoSuchAlgorithmException
     *           UnsupportedEncodingException,BadPaddingException,NoSuchPaddingException
     */
    public static String encryptBeforeDecryptKey(String key, String text)
    throws IllegalBlockSizeException,
    InvalidKeyException,
    NoSuchAlgorithmException,
    UnsupportedEncodingException,
    BadPaddingException,
    NoSuchPaddingException
    {

    	String tmpkey = decryptKey(TRUE_KEY, key);
        return encrypt(tmpkey, text);
    }
    
    /** 
     * 暗号化処理を行います。
     * @param  String key
     * @param  String text
     * @throws  IllegalBlockSizeException,InvalidKeyException,NoSuchAlgorithmException
     *           UnsupportedEncodingException,BadPaddingException,NoSuchPaddingException
     */
    public static String encrypt(String key, String text)
    throws IllegalBlockSizeException,
    InvalidKeyException,
    NoSuchAlgorithmException,
    UnsupportedEncodingException,
    BadPaddingException,
    NoSuchPaddingException
    {
        SecretKeySpec sksSpec = new SecretKeySpec(key.getBytes(), ENCRYPT_FORMAT);
        Cipher cipher = Cipher.getInstance(ENCRYPT_FORMAT);
        cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, sksSpec);
        byte[] encrypted = cipher.doFinal(text.getBytes());
        return byteArrayToHexString(encrypted);
    }
    

    /** 
     * 複合化処理を行います。
     * @param  String key
     * @param  String text
     * @throws  IllegalBlockSizeException,InvalidKeyException,NoSuchAlgorithmException
     *           UnsupportedEncodingException,BadPaddingException,NoSuchPaddingException
     */
    public static String decrypt(String key, String encrypted)
    throws IllegalBlockSizeException,
    InvalidKeyException,
    NoSuchAlgorithmException,
    UnsupportedEncodingException,
    BadPaddingException,
    NoSuchPaddingException
    {

    	key = decryptKey(TRUE_KEY, key);

        SecretKeySpec sksSpec = new SecretKeySpec(key.getBytes(), ENCRYPT_FORMAT);
        Cipher cipher = Cipher.getInstance(ENCRYPT_FORMAT);
        cipher.init(javax.crypto.Cipher.DECRYPT_MODE, sksSpec);
        byte[] decrypted = cipher.doFinal(hexStringToByteArray(encrypted));
        return new String(decrypted);
    }
    
    /** 
     * 暗号化キーの複合化処理を行います。
     * @param  String key
     * @param  String text
     * @throws  IllegalBlockSizeException,InvalidKeyException,NoSuchAlgorithmException
     *           UnsupportedEncodingException,BadPaddingException,NoSuchPaddingException
     */
    public static String decryptKey(String key, String encrypted)
    throws IllegalBlockSizeException,
    InvalidKeyException,
    NoSuchAlgorithmException,
    UnsupportedEncodingException,
    BadPaddingException,
    NoSuchPaddingException
    {
        SecretKeySpec sksSpec = new SecretKeySpec(key.getBytes(), ENCRYPT_FORMAT);
        Cipher cipher = Cipher.getInstance(ENCRYPT_FORMAT);
        cipher.init(javax.crypto.Cipher.DECRYPT_MODE, sksSpec);
        byte[] decrypted = cipher.doFinal(hexStringToByteArray(encrypted));
        return new String(decrypted);
    }

    /**
     * バイト配列を16進数の文字列に変換
     * @param arg      バイト配列
     * @return String  16進数に変換した文字列
     */
    private static String byteArrayToHexString(byte[] arg) {
        StringBuffer byteArray = new StringBuffer();
        for (int i = 0;i < arg.length; i++) {
            // 暗号化されたバイト配列の要素を2進表現の文字列に変換
            String strByteCode = Integer.toHexString((int)arg[i]);
            // STRING_SIZEの桁数に整形
            if (strByteCode.length() >= STRING_SIZE) {
                strByteCode = strByteCode.substring(strByteCode.length() - STRING_SIZE, strByteCode.length());
            } else {
                while (strByteCode.length() < STRING_SIZE) {
                    strByteCode = "0" + strByteCode;
                }
            }
            byteArray.append(strByteCode);
        }
        return byteArray.toString();
    }

    /**
     * 16進数の文字列をバイト配列に変換
     * @param arg      16進数の文字列
     * @return byte[]  バイト配列
     */
    private static byte[] hexStringToByteArray(String arg) {
        byte[] byteArray = new byte[arg.length() / STRING_SIZE];
        int j = 0;
        for(int i = 0; i < arg.length() / STRING_SIZE; i++) {
            // 文字列を1byteづつ取得
            byteArray[i] = Integer.valueOf(arg.substring(j, j + STRING_SIZE), 16).byteValue();
            j += STRING_SIZE;
        }
        return byteArray;
    }

	// ANK-2480-00-00_新電力対応 2015/05/21 add end
	//** 2016/10/12 ANK-3032-00-00 add start */

	/**
	 * 半角英数字2のドメインチェック
	 * @param str   チェック文字列
	 * @return チェック結果
	 */
	public static boolean chkHankakuEisuji2(String str)
	{
		boolean flg = false;
		if (str.length() == 0)
		{
			return false;
		}
		String strTrm = str.trim();
		if (strTrm.length() == 0)
		{
			return false;
		}
		for (int i = 0; i < str.length(); i++)
		{
			char c = str.charAt(i);
			if (c >= 0x0020 && c <= 0x007e)
			{
				flg = true;
			}
			else
			{
				return false;
			}
		}
		return flg;
	}
	//** 2016/10/12 ANK-3032-00-00 add end */

	/**
	 * 分を加算する。
	 * 
	 * @param baseDate 加算対象の日付(yyyyMMddhhmmss)
	 * @param addMinute 加算する分
	 * 
	 * @return 加算後の日付(yyyyMMddhhmmss)
	 */
	public static String addMinute(String baseDate, int addMinute) throws ParseException
	{
		SimpleDateFormat form = new SimpleDateFormat("yyyyMMddHHmmss");
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(form.parse(baseDate));
		
		calendar.add(Calendar.MINUTE, addMinute);

		return form.format(calendar.getTime());
	}
	
	/**
	 * 時間を加算する。
	 * 
	 * @param baseDate 加算対象の日付(yyyyMMddhhmmss)
	 * @param addHour 加算する時間
	 * 
	 * @return 加算後の日付(yyyyMMddhhmmss)
	 */
	public static String addHour(String baseDate, int addHour) throws ParseException
	{
		SimpleDateFormat form = new SimpleDateFormat("yyyyMMddHHmmss");
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(form.parse(baseDate));
		
		calendar.add(Calendar.HOUR, addHour);

		return form.format(calendar.getTime());
	}

	/**
	 * 月年形式(MMyy)のチェックを行います。
	 * <br>
	 * @param value チェック対象の文字列
	 * @return 月年形式の場合はtrue、それ以外の場合はfalse
	 */
	public static boolean isMonthYearCheck(String value)
	{
		if (null == value)
		{
			return true;
		}
		if (-1 != value.indexOf("/"))
		{
			value = value.replace("/", "");
		}
		if (4 != value.length())
		{
			return false;
		}
		String year = value.substring(0, 2);
		String month = value.substring(2, 4);
		String mmyy = year + month;

		return DatetimeCheck.isYearMonth2Check(mmyy);
	}
}