//====================================================================
// 日付関連スクリプト
//====================================================================

var GENGO_SYMBOL_HEISEI			= "H";		//平成(1989/01/08-)
var GENGO_SYMBOL_SYOUWA			= "S";		//昭和(1926/12/25-1989/01/07)(S01-S64)
var GENGO_SYMBOL_TAISHOU		= "T";		//大正(1912/07/30-1926/12/24)(T01-T15)
var GENGO_SYMBOL_MEIJI			= "M";		//明治(1868/01/01-1912/07/29)(M01-M45)
var GENGO_SYMBOL_KEIOU			= "K";		//慶応(1865/01/01-1868/12/31)(K01-K04)
var GENGO_SYMBOL_GENJI			= "G";		//元治(1864/01/01-1865/12/31)(G01-G02)
var GENGO_SYMBOL_BUNKYU			= "B";		//文久(1861/01/01-1864/12/31)(B01-B04)
var GENGO_SYMBOL_MANEN			= "E";		//万延(1860/01/01-1861/12/31)(E01-E02)

/*
'------------------------------------------------------------------------------
' 関数名	:IsSameDate
' 機能		:指定日付が等しいか判定する
' 返り値	:true:等しい false:等しくない
' 引き数	:dt1 - (入)指定日付(Date型)
' 				 dt2 - (入)指定日付(Date型)
' 機能説明:なし
' 備考		:なし
*/
function IsSameDate(dt1, dt2) {
	if (dt1.getFullYear() == dt2.getFullYear() &&
			dt1.getMonth() == dt2.getMonth() &&
			dt1.getDate() == dt2.getDate()) {
		return true;
	}
	return false;
}
/*
'------------------------------------------------------------------------------
' 関数名	:IsRangeDate
' 機能		:指定日付が指定範囲内か判定する
' 返り値	:true:範囲内 false:範囲外
' 引き数	:sdt - (入)範囲開始日付(Date型)
' 				 edt - (入)範囲終了日付(Date型)
' 				 tdt - (入)チェック対象日付(Date型)
' 機能説明:なし
' 備考		:なし
*/
function IsRangeDate(sdt, edt, tdt) {
	return(sdt <= tdt && edt >= tdt);
}
/*
'------------------------------------------------------------------------------
' 関数名	:getNthDate
' 機能		:指定日付の指定日数後の日付を求める
' 返り値	:指定日数後の日付
' 引き数	:dt - (入)指定日付(Date型)
' 機能説明:なし
' 備考		:なし
*/
function getNthDate(dt, nth) {
	var rdt;

	rdt = new Date(dt);
	rdt.setTime(dt.getTime() + (nth * (60 * 60 * 24 * 1000)));
	return rdt;
}
/*
'------------------------------------------------------------------------------
' 関数名	:getDateSpan
' 機能		:基準日付との差分日数を求める
' 返り値	:差分日数
' 引き数	:bdt - (入)基準日付(Date型)
' 				 tdt - (入)対象日付(Date型)
' 機能説明:なし
' 備考		:なし
*/
function getDateSpan(bdt, tdt) {
	var span;

	span = bdt.getTime() - tdt.getTime();
//	span = bdt - tdt;
	return Math.ceil(span / (1000 * 60 * 60 * 24));
/*
function count(Year,Month,Day){
   Now   = new Date();
   RunDate = new Date( Year , Month-1 , Day );
   Msec = Now.getTime()-RunDate.getTime();
   DayCount = Math.floor(Msec / (1000*60*60*24));
   document.write(DayCount); 
}
*/

}
/*
'------------------------------------------------------------------------------
' 関数名	:getDateNumber
' 機能		:指定日付の年間通算日を求める
' 返り値	:年間通算日（１月１日が０）
' 引き数	:dt - (入)指定日付(Date型)
' 機能説明:なし
' 備考		:なし
*/
function getDateNumber(dt) {
	var sdt;

	sdt = new Date(dt);
	sdt.setMonth(0);
	sdt.setDate(1);
	return(parseInt((dt.getTime() - sdt.getTime()), 10) / 60 / 60 / 24 / 1000);
}
/*
'------------------------------------------------------------------------------
' 関数名	:GetFiscalYear
' 機能		:指定日付の会計年度を算出します
' 返り値	:会計年度
' 引き数	:dt - (入)指定日付(Date型)
' 機能説明:指定日付が１〜３月の場合は、指定日付の年−１
' 				:指定日付が４〜１２月の場合は、指定日付の年
' 備考		:日付の存在チェックは行わないので必ず日付型で処理すること
*/
function GetFiscalYear(dt) {
	var fiscalyear, mon;

	fiscalyear = dt.getFullYear();
	mon = dt.getMonth() + 1;
	if (mon < 4) { fiscalyear--; }
	return fiscalyear;
}
/*
'------------------------------------------------------------------------------
' 関数名	:getDateByNthWeekday
' 機能		:指定西暦年月の第ｎ曜日を求める
' 返り値	:第ｎ曜日(Date型)（存在しない場合はnull）
' 引き数	:val - (入)指定年月(yyyymm)
' 				 nth - (入)第ｎ指定（１〜５）
' 				 day - (入)曜日（0:日 1:月 2:火 3:水 4: 木 5:金 6:土）
' 機能説明:なし
' 備考		:なし
*/
function getDateByNthWeekday(val, nth, weekday) {
	var yyyy, mm, offset, topdate, rval;

	rval = null;
	if (nth >= 1 && nth <= 5) {
		yyyy = eval(val.substr(0, 4));
		mm = eval(val.substr(4, 2)) - 1;
		topdate = new Date(yyyy, mm, 1);
		offset = weekday - topdate.getDay();
		if (offset >= 0) { nth--; }
		rval = new Date(yyyy, mm, offset + nth * 7 + 1);
	}
	return rval;
}
/*
'------------------------------------------------------------------------------
' 関数名	:DateToString
' 機能		:指定日付の指定フォーマット文字列の文字列を生成する
' 返り値	:文字列
' 引き数	:dt - (入)指定日付(Date型)
' 機能説明:なし
' 備考		:なし
*/
function DateToString(dt, fmt) {
	var spos, epos, pat;
	var rval;

	rval = "";
	if (dt != null) {
		for (spos = 0, epos = 0; ; epos++) {
			if (epos == fmt.length) {
				pat = fmt.substring(spos);
				rval += DateToStringByPrimitivePattern(dt, pat);
				break;
			}
			if (fmt.charCodeAt(spos) != fmt.charCodeAt(epos)) {
				pat = fmt.substring(spos, epos);
				rval += DateToStringByPrimitivePattern(dt, pat);
				spos = epos;
			}
		}
	}
	return rval;
}
/*
'------------------------------------------------------------------------------
' 関数名	:DateToStringByPrimitivePattern
' 機能		:指定日付の最小単位フォーマット文字列の文字列を生成する
' 返り値	:文字列
' 引き数	:dt - (入)指定日付(Date型)
' 				 pat - (入)最小単位フォーマット文字列
' 機能説明:なし
' 備考		:なし
*/
function DateToStringByPrimitivePattern(dt, pat) {
	var rval;

	switch (pat) {
		case "a":			//曜日を日本語で返します (日〜土)。
			var day_string = Array("日","月","火","水","木","金","土");
			rval = day_string[dt.getDay()];
			break;
		case "d":			//日付を返します。１桁の場合、先頭に０が付きません(1〜31)。
			rval = (dt.getDate()).toString();
			break;
		case "dd":		//日付を返します。１桁の場合、先頭に０が付きます(01〜31)。
			rval = PaddingToString(dt.getDate(), 2, "0");
			break;
		case "m":			//月を返します。１桁の場合、先頭に０が付きません(1〜12)。
			rval = (dt.getMonth() + 1).toString();
			break;
		case "mm":		//月を返します。１桁の場合、先頭に０が付きます(01〜12)。
			rval = PaddingToString(dt.getMonth() + 1, 2, "0");
			break;
		case "w":			//和暦元号を返します。（E/B/G/K/M/H/T/S）
			rval = getJapaneseYearSymbol(dt);
			break;
		case "W":			//和暦元号を返します。（万延・文久・元治・慶応・明治・大正・昭和・平成）
			rval = getJapaneseYearName(dt);
			break;
		case "Y":			//和暦年を返します。１桁の場合、先頭に０が付きません。
			rval = getJapaneseYear(dt).toString();
			break;
		case "YY":		//和暦年を返します。１桁の場合、先頭に０が付きます(01〜99)。
			rval = PaddingToString(getJapaneseYear(dt), 2, "0");
			break;
		case "yyyy":	//西暦年を返します。4 桁未満の場合 0 が付きます (0001 〜 9999)。
			rval = PaddingToString(dt.getFullYear(), 4, "0");
			break;
		case "H":			//時を返します。１桁の場合、先頭に０が付きません。
			rval = dt.getHours().toString();
			break;
		case "HH":		//時を返します。2 桁未満の場合 0 が付きます (00 〜 23)。
			rval = PaddingToString(dt.getHours(), 2, "0");
			break;
		case "M":			//分を返します。１桁の場合、先頭に０が付きません。
			rval = dt.getMinutes().toString();
			break;
		case "MM":		//分を返します。2 桁未満の場合 0 が付きます (00 〜 59)。
			rval = PaddingToString(dt.getMinutes(), 2, "0");
			break;
		case "S":			//秒を返します。１桁の場合、先頭に０が付きません。
			rval = dt.getSeconds().toString();
			break;
		case "SS":		//秒を返します。２桁未満の場合 0 が付きます (00 〜 59)。
			rval = PaddingToString(dt.getSeconds(), 2, "0");
			break;
		case "s":			//ミリ秒を返します。３桁未満の場合、先頭に０が付きません。
			rval = dt.getMilliseconds().toString();
			break;
		case "sss":		//ミリ秒を返します。３桁未満の場合 0 が付きます (000 〜 999)。
			rval = PaddingToString(dt.getMilliseconds(), 3, "0");
			break;
		default:
			rval = pat;
			break;
	}
	return rval;
}
/*
'------------------------------------------------------------------------------
' 関数名	:JapaneseYearToADYear
' 機能		:指定和暦年を西暦年に変換します
' 返り値	:西暦年
' 引き数	:val - (入)指定和暦年文字列(yy or Myy,Tyy,Syy,Hyy, myy, tyy, syy, hyy)
' 機能説明:元号指定がない場合は、平成として処理する
' 備考		:指定和暦年文字列が許容フォーマット以外の場合は、０を返す
' 				 元号指定の場合、指定元号にない年の場合は、０を返す
*/
function JapaneseYearToADYear(val) {
	var rval, yyyy, symbol;

	rval = val.match("[e,b,g,k,m,t,s,h,E,B,G,K,M,T,S,H]*[0-9]{1,2}");
	if (rval == null) { return 0; }
	if (rval.length > 1) { return 0; }
	if (rval[0].length != val.length) { return 0; }
	if (val.length == 2) { val = GENGO_SYMBOL_HEISEI + val; }
	else { val = val.toUpperCase(); }
	yyyy = eval(val.substr(1));
	if (yyyy == 0) { return 0; }
	symbol = val.substr(0, 1)
	if (yyyy <= getMaxEraYear(symbol)) { yyyy = yyyy - 1 + getStartEraADYear(symbol); }
	else { yyyy = 0; }
	return yyyy;
}
/*
'------------------------------------------------------------------------------
' 関数名	:MakeDateByDateFormat
' 機能		:西暦日付フォーマット文字列から日付オブジェクトを生成します
' 返り値	:日付オブジェクト(フォーマット不良の場合は、null)
' 引き数	:val - (入)西暦日付フォーマット文字列(yyyymmddHHMMSS)
' 機能説明:なし
' 備考		:なし
*/
function MakeDateByDateFormat(val) {
	var yyyy, mm, dd, HH, MM, SS;

	if (val.length != 14) { return null; }
	yyyy = eval(val.substr(0, 4));
	mm = eval(val.substr(4, 2)) - 1;
	dd = eval(val.substr(6, 2));
	HH = eval(val.substr(8, 2));
	MM = eval(val.substr(10, 2));
	SS = eval(val.substr(12, 2));
	return (new Date(yyyy, mm, dd, HH, MM, SS));
}
/*
'------------------------------------------------------------------------------
' 関数名	:MakeDateByJapaneseDateFormat
' 機能		:和暦日付フォーマット文字列から日付オブジェクトを生成します
' 返り値	:日付オブジェクト(フォーマット不良の場合は、null)
' 引き数	:val - (入)和暦日付フォーマット文字列
' 		yymmdd, Eyymmdd, Byymmdd, Gyymmdd, Kyymmdd, Myymmdd, Tyymmdd, Syymmdd
' 						eyymmdd, byymmdd, gyymmdd, kyymmdd, myymmdd, tyymmdd, syymmdd
' 機能説明:元号指定がない場合は、平成として処理する
' 備考		:年の変換にJapaneseYearToADYearを使用している
*/
function MakeDateByJapaneseDateFormat(val) {
	var yyyy, mm, dd;

	if (val.length > 6) {
		yyyy = JapaneseYearToADYear(val.substr(0, 3));
		mm = eval(val.substr(3, 2)) - 1;
		dd = eval(val.substr(5, 2));
	} else if (val.length == 6) {
		yyyy = JapaneseYearToADYear(val.substr(0, 2));
		mm = eval(val.substr(2, 2)) - 1;
		dd = eval(val.substr(4, 2));
	} else { return null; }
	if (yyyy == 0 ) { return null; }
	return (new Date(yyyy, mm, dd));
}
/*
'------------------------------------------------------------------------------
' 関数名	:getJapaneseYearSymbol
' 機能		:指定日付の和暦元号記号文字を求める
' 返り値	:和暦元号記号文字
' 引き数	:dt - (入)指定日付(Date型)
' 機能説明:なし
' 備考		:なし
*/
function getJapaneseYearSymbol(dt) {
	var yyyy, mm, dd, rval;

	yyyy = dt.getFullYear();
	mm = dt.getMonth() + 1;
	dd = dt.getDate();
	if (yyyy >= getStartEraADYear(GENGO_SYMBOL_HEISEI)) {
		rval = GENGO_SYMBOL_HEISEI;
		if (yyyy == getStartEraADYear(GENGO_SYMBOL_HEISEI) && mm == 1 && dd < 8) {
			rval = GENGO_SYMBOL_SYOUWA;
		}
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_SYOUWA)) {
		rval = GENGO_SYMBOL_SYOUWA;
		if (yyyy == getStartEraADYear(GENGO_SYMBOL_SYOUWA) && mm == 12 && dd < 25) {
			rval = GENGO_SYMBOL_TAISHOU;
		}
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_TAISHOU)) {
		rval = GENGO_SYMBOL_TAISHOU;
		if (yyyy == getStartEraADYear(GENGO_SYMBOL_TAISHOU) && mm == 7 && dd < 30) {
			rval = GENGO_SYMBOL_MEIJI;
		}
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_MEIJI)) {
		rval = GENGO_SYMBOL_MEIJI;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_KEIOU)) {
		rval = GENGO_SYMBOL_KEIOU;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_GENJI)) {
		rval = GENGO_SYMBOL_GENJI;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_BUNKYU)) {
		rval = GENGO_SYMBOL_BUNKYU;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_MANEN)) {
		rval = GENGO_SYMBOL_MANEN;
	} else {
		rval = "";
	}
	return rval;
}
/*
'------------------------------------------------------------------------------
' 関数名	:getJapaneseYearSymbolByYear
' 機能		:指定西暦年の和暦元号記号文字を求める
' 返り値	:和暦元号記号文字
' 引き数	:yyyy - (入)指定西暦年
' 機能説明:なし
' 備考		:なし
*/
function getJapaneseYearSymbolByYear(yyyy) {
	if (yyyy >= getStartEraADYear(GENGO_SYMBOL_HEISEI)) {
		rval = GENGO_SYMBOL_HEISEI;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_SYOUWA)) {
		rval = GENGO_SYMBOL_SYOUWA;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_TAISHOU)) {
		rval = GENGO_SYMBOL_TAISHOU;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_MEIJI)) {
		rval = GENGO_SYMBOL_MEIJI;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_KEIOU)) {
		rval = GENGO_SYMBOL_KEIOU;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_GENJI)) {
		rval = GENGO_SYMBOL_GENJI;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_BUNKYU)) {
		rval = GENGO_SYMBOL_BUNKYU;
	} else if (yyyy >= getStartEraADYear(GENGO_SYMBOL_MANEN)) {
		rval = GENGO_SYMBOL_MANEN;
	} else {
		rval = "";
	}
	return rval;
}
/*
'------------------------------------------------------------------------------
' 関数名	:getJapaneseYearName
' 機能		:指定日付の和暦元号を求める
' 返り値	:和暦元号
' 引き数	:dt - (入)指定日付(Date型)
' 機能説明:なし
' 備考		:なし
*/
function getJapaneseYearName(dt) {
	return getJapaneseYearNameBySymbol(getJapaneseYearSymbol(dt));
}
/*
'------------------------------------------------------------------------------
' 関数名	:getJapaneseYearNameBySymbol
' 機能		:指定和暦元号記号文字の和暦元号を求める
' 返り値	:和暦元号
' 引き数	:symbol - (入)和暦元号記号文字
' 機能説明:なし
' 備考		:なし
*/
function getJapaneseYearNameBySymbol(symbol) {
	switch(symbol) {
		case GENGO_SYMBOL_HEISEI:		rval = "平成"; break;
		case GENGO_SYMBOL_SYOUWA:		rval = "昭和"; break;
		case GENGO_SYMBOL_TAISHOU:	rval = "大正"; break;
		case GENGO_SYMBOL_MEIJI:		rval = "明治"; break;
		case GENGO_SYMBOL_KEIOU:		rval = "慶応"; break;
		case GENGO_SYMBOL_GENJI:		rval = "元治"; break;
		case GENGO_SYMBOL_BUNKYU:		rval = "文久"; break;
		case GENGO_SYMBOL_MANEN:		rval = "万延"; break;
		default: rval = ""; break;
	}
	return rval;
}
/*
'------------------------------------------------------------------------------
' 関数名	:getJapaneseYear
' 機能		:指定日付の和暦年を求める
' 返り値	:和暦年
' 引き数	:dt - (入)指定日付(Date型)
' 				 symbol - (入)和暦元号記号文字
' 機能説明:なし
' 備考		:なし
*/
function getJapaneseYear(dt, symbol) {
	if (symbol == null) { symbol = getJapaneseYearSymbol(dt); }
	return dt.getFullYear() - getStartEraADYear(symbol) + 1;	
}
/*
'------------------------------------------------------------------------------
' 関数名	:getStartEraADYear
' 機能		:指定和暦元号記号文字の開始西暦年を求める
' 返り値	:開始西暦年
' 引き数	:symbol - (入)和暦元号記号文字
' 機能説明:なし
' 備考		:なし
*/
function getStartEraADYear(symbol) {
	switch(symbol) {
		default:
		case GENGO_SYMBOL_HEISEI:		rval = 1989; break;
		case GENGO_SYMBOL_SYOUWA:		rval = 1926; break;
		case GENGO_SYMBOL_TAISHOU:	rval = 1912; break;
		case GENGO_SYMBOL_MEIJI:		rval = 1868; break;
		case GENGO_SYMBOL_KEIOU:		rval = 1865; break;
		case GENGO_SYMBOL_GENJI:		rval = 1864; break;
		case GENGO_SYMBOL_BUNKYU:		rval = 1861; break;
		case GENGO_SYMBOL_MANEN:		rval = 1860; break;
	}
	return rval;
}
/*
'------------------------------------------------------------------------------
' 関数名	:getMaxEraYear
' 機能		:指定和暦元号記号文字の最大年を求める
' 返り値	:最大年
' 引き数	:symbol - (入)和暦元号記号文字
' 機能説明:なし
' 備考		:なし
*/
function getMaxEraYear(symbol) {
	switch(symbol) {
		default:
		case GENGO_SYMBOL_HEISEI:		rval = 99; break;
		case GENGO_SYMBOL_SYOUWA:		rval = 64; break;
		case GENGO_SYMBOL_TAISHOU:	rval = 15; break;
		case GENGO_SYMBOL_MEIJI:		rval = 45; break;
		case GENGO_SYMBOL_KEIOU:		rval = 3; break;
		case GENGO_SYMBOL_GENJI:		rval = 1; break;
		case GENGO_SYMBOL_BUNKYU:		rval = 3; break;
		case GENGO_SYMBOL_MANEN:		rval = 1; break;
	}
	return rval;
}
/*
'------------------------------------------------------------------------------
' 関数名	:IsExistJapaneseDate
' 機能		:指定和暦日付が存在するか判定します
' 返り値	:true:存在する false:存在しない
' 引き数	:val - (入)指定和暦日付(Xyymmdd)
' 機能説明:なし
' 備考		:なし
*/
function IsExistJapaneseDate(val) {
	var dt;

	dt = MakeDateByJapaneseDateFormat(val);
	return (DateToString(dt, "wYYmmdd") == val);
}
/*
'------------------------------------------------------------------------------
' 関数名	:IsExistJapaneseYearMonth
' 機能		:指定和暦年月が存在するか判定します
' 返り値	:true:存在する false:存在しない
' 引き数	:val - (入)指定和暦年月(Xyymm)
' 機能説明:なし
' 備考		:なし
*/
function IsExistJapaneseYearMonth(val) {
	var symbol, yy, mm, rval;

	rval = false;
	symbol = val.substr(0, 1);
	yy = eval(val.substr(1, 2));
	mm = eval(val.substr(3, 2));
	if (yy > 0 && mm > 0 && yy <= getMaxEraYear(symbol)) {
		switch(symbol) {
			case GENGO_SYMBOL_HEISEI:
				rval = true;
				break;
			case GENGO_SYMBOL_SYOUWA:
				if (yy == 1) {
					if (mm == 12) { rval = true; }
				} else if (yy == 64) {
					if (mm == 1) { rval = true; }
				} else if (yy < 64) {
					rval = true;
				}
				break;
			case GENGO_SYMBOL_TAISHOU:
				if (yy == 1) {
					if (mm >= 7) { rval = true; }
				} else if (yy <= 15) {
					rval = true;
				}
				break;
			case GENGO_SYMBOL_MEIJI:
				if (yy == 45) {
					if (mm <= 7) { rval = true; }
				} else if (yy < 45) {
					rval = true;
				}
				break;
			case GENGO_SYMBOL_KEIOU:
				if (yy >= 1 && yy <= 4) { rval = true; }
				break;
			case GENGO_SYMBOL_GENJI:
				if (yy >= 1 && yy <= 2) { rval = true; }
				break;
			case GENGO_SYMBOL_BUNKYU:
				if (yy >= 1 && yy <= 4) { rval = true; }
				break;
			case GENGO_SYMBOL_MANEN:
				if (yy >= 1 && yy <= 2) { rval = true; }
				break;
			default:
				break;
		}
	}
	return rval;
}
/*
'------------------------------------------------------------------------------
' 関数名	:IsExistJapaneseYear
' 機能		:指定和暦年が存在するか判定します
' 返り値	:true:存在する false:存在しない
' 引き数	:val - (入)指定和暦年(Xyy)
' 機能説明:なし
' 備考		:なし
*/
function IsExistJapaneseYear(val) {
	var symbol, yy, rval;

	rval = false;
	symbol = val.substr(0, 1);
	yy = eval(val.substr(1, 2));
	if (yy > 0 && yy <= getMaxEraYear(symbol)) { rval = true; }
	return rval;
}
/*------<< EOF >>------*/