/*************************************************************************/
/*  1. 시 스 템 명 : 공통                                                */
/*  2. 프로그램 ID : valid.js                                            */
/*  3. 프로그램 명 : 전략물자 유효성점검을 위한 JavaScript 함수 모음     */
/*  4. 작  성   일 : 2004.10.25                                          */
/*  5. 작  성   자 : 한승훈                                              */
/*  6. 개       요 : 업무 내용과 관련된 JavaScript 함수를 정의한다.      */
/*************************************************************************/
/* LAST DATE    Author   DESCRIPTION                                     */
/* -----------  -------  ----------------------------------------------- */
/* 2004.10.25   한승훈   최초생성                                        */
/*************************************************************************/

/**
 * 주어진 문자열 값이 유효한 날짜 형식인지를 확인하여
 * 유효하면 true를 돌려주고, 유효하지 않으면 적절한 오류 메시지를
 * 보여준 다음 false를 돌려준다.
 */
function checkYearMonth(dateStr) {
	// 아무값도 없으면 진행하지 않는다.
	if ( trim(dateStr) == "" ) return true;

	dateStr = removeChar(dateStr, '/');

	// 슬래쉬를 제거한 나머지 자릿수가 8자인지 검사한다.
	if (dateStr.length != 6) {
		alert("YYYYMM의 형식으로 입력해 주십시오.");
		return false;
	}

	// 숫자로만 구성되었는지 확인한다.
	if ( isNaN(dateStr) ) {
		alert("날짜에는 문자가 입력될 수 없습니다.");
		return false;
	}

	// 연도 4자리, 월 2자리로 자른다.
	var yearStr  = dateStr.substring(0, 4);
	var monthStr = dateStr.substring(4);


	// 연도 값이 1900 ~ 2050 사이인지 점검한다.
	if ( yearStr < 1900 || yearStr > 2050 ) {
		alert("연도는 1900년 ~ 2050년 사이의 값을 입력해야 합니다.");
		return false;
	}

	// 월이 1~12월 사이인지 점검한다.
	if ( monthStr < 1 || monthStr > 12 ) {
		alert("월은 01월에서 12월 사이의 값입니다.");
		return false;
	}

	return true;
}


/**
 * Text형 입력폼의 문자열 값이 유효한 날짜 형식인지를 확인하여
 * 유효하면 연월 값 사이에 슬래쉬(/)를 넣은 문자열로 바꾼 후 true를 돌려주고,
 * 유효하지 않으면 적절한 오류 메시지를 보여준 다음 false를 돌려준다.
 */
function checkYearMonthObj(obj) {
	var dateStr = removeChar(obj.value, '/');

	var valid = true;

	// 빈 문자열이면 점검하지 않는다.
	if ( trim(dateStr) != "" ) {
		valid = checkYearMonth(dateStr);
		if ( valid ) {
			var yearStr  = dateStr.substring(0, 4);
			var monthStr = dateStr.substring(4);

			obj.value = yearStr + "/" + monthStr;
		}
		else {
			obj.focus();
		}
	}

	return valid;
}


/**
 * Text형 입력폼 에 입력된 날짜가 유효한지 체크하여
 * 유효하면 YYYY/MM/DD의 형태로 변환하여 return
 * 하고, 유효하지 않으면 에러메세지 보여줌
 * (년월일 입력필드의 onblur event에 사용할것)
 *
 * @param obj Text형 입력폼 객체
 */
function checkDateObj(obj) {
	var dateStr = removeChar(obj.value, '/');

	var valid = true;

	// 빈 문자열이면 점검하지 않는다.
	if ( trim(dateStr) != "" ) {
		valid = checkDate(dateStr);
		if ( valid ) {
			var yearStr  = dateStr.substring(0, 4);
			var monthStr = dateStr.substring(4, 6);
			var dayStr   = dateStr.substring(6);
			obj.value = yearStr +  monthStr +  dayStr;
		}
		else {
			obj.focus();
		}
	}

	return valid;
}

//자릿수와 해당 object를 받아서 체크함...onFocusOut이나나 validation check할때 사용
function checkHSKCd(obj, len){
	var hsk = obj.value;
	//alert(isNumeric(hsk) );
	
	if( isNumeric(hsk) ){
		if( hsk.length == len ){
			return true;
		}else if( hsk.length > len ){
			alert('hsk코드 자릿수를 초과하였습니다.');
			obj.focus();
			return false;
		}else if( hsk.length < len ){
			alert('hsk코드 자릿수가 모자랍니다.');
			obj.focus();
			return false;
		}
	}else{
		alert('HSK코드값에 문자를 입력하였습니다.');
		obj.focus();
		return false;
	}
}

function checkNum() {
	if (event.keyCode < 48 || event.keyCode > 57) {
		event.returnValue = false;
	}
}

// 숫자인지 체크하는 함수
function isNumeric(numStr) {

	return !isNaN(numStr);
}

/**
 * 주어진 문자열값이 유효한 날짜값인지 점검하여
 * 유효하면 true를 돌려주고, 유효하지 않으면
 * 에러메세지를 보여주고 false를 돌려준다.
 * (년월일 입력필드의 onblur event에 사용할것)
 *
 * @param dateStr 날짜형값을 가지는 문자열
 */
function checkDate(dateStr) {
	// 아무값도 없으면 진행하지 않는다.
	if ( trim(dateStr) == "" ) return true;

	dateStr = removeChar(dateStr, '/');

	// 슬래쉬를 제거한 나머지 자릿수가 8자인지 검사한다.
	if (dateStr.length != 8) {
		alert("YYYYMMDD의 형식으로 입력해 주십시오.");
		return false;
	}

	// 숫자로만 구성되었는지 확인한다.
	if ( isNaN(dateStr) ) {
		alert("날짜에는 문자가 입력될 수 없습니다.");
		return false;
	}

	// 연도 4자리, 월 2자리, 일 2자리로 자른다.
	var yearStr  = dateStr.substring(0, 4);
	var monthStr = dateStr.substring(4, 6);
	var dayStr   = dateStr.substring(6);


	// 연도 값이 1900 ~ 2050 사이인지 점검한다.
	if ( yearStr < 1900 || yearStr > 2050 ) {
		alert("연도는 1900년 ~ 2050년 사이의 값을 입력해야 합니다.");
		return false;
	}

	// 월이 1~12월 사이인지 점검한다.
	if ( monthStr < 1 || monthStr > 12 ) {
		alert("월은 1월에서 12월 사이의 값입니다.");
		return false;
	}

	// 일자가 해당월의 유효한 일자인지 검검한다.
	// Date 객체 생성시 날짜가 유효범위를 넘어서면
	// 달이 변하는 원리를 이용했다.
	var date = new Date(yearStr, monthStr - 1, dayStr);

	if (yearStr != date.getFullYear() || monthStr != (date.getMonth() + 1)) {
		alert(monthStr + "월에는 " + dayStr + "일이 없습니다.");
		return false;
	}

	return true;
}


/**
 * 두개의 연월(yyyy/MM형식) 문자열을 비교하여 앞 연월이 뒤 연월과
 * 같으면 0, 앞 연월이 뒤 연월보다 빠르면 1, 앞 연월이 뒤 연월보다
 * 느리면 -1을 돌려 준다.
 *
 * @param yearMonth1  앞 연월
 * @param yearMonth2  뒤 연월
 */
function compareYearMonth(yearMonth1, yearMonth2) {
	var result = 0;

	yearMonth1 = removeChar(yearMonth1, '/');
	yearMonth2 = removeChar(yearMonth2, '/');

	if ( yearMonth1 < yearMonth2 ) {
		result = 1;
	}
	else if ( yearMonth1 > yearMonth2 ) {
		result = -1;
	}

	return result;
}


/**
 * 두개의 Text형 입력폼의 연월(yyyy/MM형식) 문자열 값을 비교하여
 * 앞 연월이 뒤 연월과 같으면 0, 앞 연월이 뒤 연월보다 빠르면 1,
 * 앞 연월이 뒤 연월보다 느리면 -1을 돌려 준다.
 *
 * @param obj1  앞 연월값을 가지는 Text형 입력폼
 * @param obj2  뒤 연월값을 가지는 Text형 입력폼
 */
function compareYearMonthObj(obj1, obj2) {
	return compareYearMonth(obj1.value, obj2.value);
}


/**
 * 두개의 날짜 문자열을 비교하여 첫번째 파라미터(date1)의
 * 날짜 값이 두번째 파라미터(date2)의 날짜 값과 비교하여
 * 이르면 1을, 같으면 0을, 늦으면 -1을 돌려 준다.
 * date1은 값이 있고, date2는 값이 없으면 -1,
 * date1은 값이 없고, date2는 값이 있으면 1 이다.
 *
 * @param date1 yyyyMMdd형식의 날짜형 문자열.
 * @param date2 yyyyMMdd형식의 날짜형 문자열.
 */
function compareDate(date1, date2) {
	date1 = removeChar(date1, '/');
	date2 = removeChar(date2, '/');

	var result = 0;

	if ( date1 < date2 ) {
		result = 1;
	}
	else if ( date1 > date2 ) {
		result = -1;
	}

	return result;
}


/**
 * 두개의 날짜 문자열을 비교하여 첫번째 파라미터(obj1)의
 * 날짜 값이 두번째 파라미터(obj2)의 날짜 값과 비교하여
 * 이르면 1을, 같으면 0을, 늦으면 -1을 돌려 준다.
 * obj1은 값이 있고, obj2는 값이 없으면 -1,
 * obj1은 값이 없고, obj2는 값이 있으면 1 이다.
 *
 * @param obj1 Text형 입력폼 객체
 * @param obj2 Text형 입력폼 객체
 */
function compareDateObj(obj1, obj2) {
	return compareDate(obj1.value, obj2.value);
}


/**
 * Text형 입력폼에 입력된 시간(시+분)이 유효한지
 * 체크하여 유효하면 hh24:mi의 형태로 변환하여
 * return하고, 유효하지 않으면 에러메세지를
 * 보여줌(시간 입력필드의 onblur event에 사용)
 */
function checkTimeObj(obj) {
	var timeStr = obj.value;

	var valid = true;

	// 빈 문자열이면 점검하지 않는다.
	if ( trim(timeStr) != "" ) {
		valid = checkTime(timeStr);

		if ( valid ) {
			var hourStr   = timeStr.substring(0, 2);
			var minuteStr = timeStr.substring(2);

			obj.value = hourStr + ":" + minuteStr;
		}
		else {
			obj.focus();
		}
	}

	return valid;
}


/**
 * Text형 입력폼에 입력된 시간(시+분)이 유효한지
 * 체크하여 유효하면 hh24:mi의 형태로 변환하여
 * return하고, 유효하지 않으면 에러메세지를
 * 보여줌(시간 입력필드의 onblur event에 사용)
 *
 * @param timeStr  HHmm 형식의 시간형 문자열
 */
function checkTime(timeStr) {
	if ( trim(timeStr) == "" ) return true;

	timeStr = removeChar(timeStr, ':');

	// 길이가 4인지 점검한다.
	if ( timeStr.length != 4 ) {
		alert("형식이 맞지 않습니다. \"HHmm\" 형태의 숫자로 입력해 주십시오.");
		return false;
	}

	// 숫자로만 구성되었는지 점검한다.
	if ( isNaN(timeStr) ) {
		alert("문자열은 입력할 수 없습니다. \"HHmm\" 형태의 숫자로 입력해 주십시오.");
		return false;
	}

	// 시간 2자리, 분 2자리로 분리한다.
	var hourStr   = timeStr.substring(0, 2);
	var minuteStr = timeStr.substring(2);

	if ( hourStr < 0 || hourStr > 23 ) {
		alert("시간 값은 00에서 23 사이의 값이어야 합니다.");
		return false;
	}


	if ( minuteStr < 0 || minuteStr > 59 ) {
		alert("분 값은 00에서 59 사이의 값이어야 합니다.");
		return false;
	}

	return true;
}


/**
 * 눌린 키가 Control Key이면 true, 아니면 false
 */
function isControlKey() {
	var key = event.keyCode;

	return (
		   key ==   8  // <BS>
		|| key ==   9  // <Tab>
		|| key ==  13  // <Enter>
		|| key ==  35  // <End>
		|| key ==  36  // <Home>
		|| key ==  37  // <←>
		|| key ==  39  // <→>
		|| key ==  46  // <Del>
		|| key == 144  // <NumLock>
	);
}


/**
 * 눌린키가 숫자키면 true, 아니면 false
 */
function isDigitKey() {
	var key = event.keyCode;

	return ( key >= 48 && key <= 57 ) || ( key >= 96 && key <= 105 );
}


/**
 * 눌린키가 특수문자키이면 true, 아니면 false;
 */
function isSpecialCharKey() {
}

/**
 * 정수만 입력받고자 하는 경우의 onKeyDown이벤트 핸들러
 */
function limitAsInt(limit) {
	if ( isControlKey() ) {
		event.returnValue = true;
		return ;
	}

	var key = event.keyCode;
	var str = event.srcElement.value;

	var intLengthValid = true;

	// 정수 자리수가 찼는지 검사하여 찼으면
	// 더 이상 입력할 수 없게 한다. 이 때 자릿수에서
	// 앞에 양음 기호(+/-)는 제한다.
	if ( limit != undefined ) {
		var intLength = removeChar(str, ',').length;
		if ( str.charAt(0) == '-' || str.charAt(0) == '+' ) {
			intLength--;
		}

		intLengthValid = intLength < limit;
	}

	event.returnValue = intLengthValid && (
		isDigitKey()
		|| key == 189 || key == 109 // <->
	);
}


/**
 * 양의 정수만 입력받고자 하는 경우의 onKeyDown이벤트 핸들러
 */
function limitAsPlusInt(limit) {
	if ( isControlKey() ) {
		event.returnValue = true;
		return ;
	}

	var key = event.keyCode;
	var str = event.srcElement.value;

	var intLengthValid = true;

	// 정수 자리수가 찼는지 검사하여 찼으면
	// 더 이상 입력할 수 없게 한다.
	if ( limit != undefined ) {
		intLengthValid = removeChar(str, ',').length < limit;
	}

	event.returnValue = intLengthValid && isDigitKey();
}


/**
 * 실수를 입력받고자 하는 경우의 onKeyDown이벤트 핸들러
 */
function limitAsFloat(limit) {
	if ( isControlKey() ) {
		event.returnValue = true;
		return ;
	}

	var str = event.srcElement.value;
	var key = event.keyCode;

	var dotNoValid = true;

	// 소숫점 자리수가 찼는지 검사하여 찼으면
	// 더 이상 입력할 수 없게 한다.
	if ( limit != undefined ) {
		var dotIndex = str.lastIndexOf('.');

		if ( dotIndex > -1 ) {
			dotNoValid = str.length - dotIndex - 1 < limit;
		}
	}

	var dotValid = true;

	// 소숫점이 이미 찍혔으면 소숫점은 더 찍지 못하게 한다.
	if ( str.indexOf('.') > -1 && ( key == 190 || key == 229 ) ) {
		dotValid = false;
	}

	event.returnValue = dotValid && dotNoValid && (
		isDigitKey()
		|| key == 189 || key == 109 // <->
		|| key == 190 || key == 229 || key == 110 // <.>
	);
}


/**
 * 양의 실수를 입력받고자 하는 경우의 onKeyDown이벤트
 */
function limitAsPlusFloat(limit) {
	if ( isControlKey() ) {
		event.returnValue = true;
		return ;
	}

	var str = event.srcElement.value;
	var key = event.keyCode;

	var dotNoValid = true;

	// 소숫점 자리수가 찼는지 검사하여 찼으면
	// 더 이상 입력할 수 없게 한다.
	if ( limit != undefined ) {
		var dotIndex = str.lastIndexOf('.');

		if ( dotIndex > -1 ) {
			dotNoValid = str.length - dotIndex - 1 < limit;
		}
	}

	var dotValid = true;

	// 소숫점이 이미 찍혔으면 소숫점은 더 찍지 못하게 한다.
	if ( str.indexOf('.') > -1 && ( key == 190 || key == 229 ) ) {
		dotValid = false;
	}

	event.returnValue = dotValid && dotNoValid && (
		 isDigitKey()
		|| key == 190 || key == 229 || key == 110 // <.>
	);
}

/**
 * 한글과 스페이스 Key만 허용한다.
 */
function limitAsHangul() {
	if ( isControlKey() ) {
		event.returnValue = true;
		return ;
	}

	var key = event.keyCode;

	event.returnValue = (
		key == 32      // 스페이스키
		|| key == 229  // 한글키. 근데 왜 한글은 무조건 229일까?
	);
}


/**
 * 한글과 숫자, 스페이스 Key만 허용한다.
 */
function limitAsHangulAndNo() {
	if ( isControlKey() ) {
		event.returnValue = true;
		return ;
	}

	var key = event.keyCode;

	event.returnValue = isDigitKey() || (
		key == 32      // 스페이스키
		|| key == 229  // 한글키. 근데 왜 한글은 무조건 229일까?
	);
}


/**
 * Text형 입력폼의 값이 유효한 숫자값인지 점검하여
 * 유효한 숫자이면 true를, 그렇지 않으면 false를 돌려준다.
 * 값이 빈 문자열이면 false를 돌려주는 것에 주의한다.
 *
 * @param obj Text형 입력폼 객체
 */
function checkNumberObj(obj) {
	return checkNumber(obj.value);
}


/**
 * 비축 업무에서는 숫자에 3자리마다 컴마가 들어간
 * 수치값을 사용한다. 이를 고려한 숫자여부를 점검하여
 * 유효한 숫자이면 true를, 그렇지 않으면 false를
 * 돌려준다. 값이 빈 문자열이면 false를 돌려주므로
 * 빈값이 아닌지를 점검하여 사용하는 것에 주의한다.
 *
 * @param  str  검사할 문자열
 */
function checkNumber(str) {
	return ! isNaN( removeChar(str, ',') );
}


/**
 * 주어진 문자열의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param str    대상 문자열
 * @param length 비교 byte 수
 */
function checkLengthEQ(str, length) {
	return countByte(str) ==  length;
}


/**
 * Text형 입력폼 값의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param obj    Text형 입력폼 객체
 * @param length 비교 byte 수
 */
function checkLengthEQObj(obj, length) {
	return checkLengthEQ(obj.value, length);
}


/**
 * 주어진 문자열의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param str    대상 문자열
 * @param length 비교 byte 수
 */
function checkLengthGT(str, length) {
	return countByte(str) > length;
}


/**
 * Text형 입력폼 값의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param obj    Text형 입력폼 객체
 * @param length 비교 byte 수
 * @param fieldName 항목명
 */
function checkLengthGTObj(obj, length, fieldName) {
	if ( fieldName == undefined ) {
		fieldName = "";
	}
	else {
		fieldName += "의 ";
	}

	var valid = checkLengthGT(obj.value, length);

	if ( valid ) {
		alert(fieldName + "입력값이 한도를 초과하였습니다.\n\n영문 " + length + "자, 한글 " + (length / 2) + "자까지 가능합니다.");
		obj.focus();
	}

	return valid;
}


/**
 * 주어진 문자열의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param str    대상 문자열
 * @param length 비교 byte 수
 */
function checkLengthLT(str, length) {
	return countByte(str) < length;
}


/**
 * Text형 입력폼 값의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param obj    Text형 입력폼 객체
 * @param length 비교 byte 수
 */
function checkLengthLTObj(obj, length) {
	return checkLengthLT(obj.value, length);
}


/**
 * 주어진 문자열의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param str    대상 문자열
 * @param length 비교 byte 수
 */
function checkLengthGE(str, length) {
	return countByte(str) >= length;
}


/**
 * Text형 입력폼 값의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param obj    Text형 입력폼 객체
 * @param length 비교 byte 수
 */
function checkLengthGEObj(obj, length) {
	var valid = checkLengthGE(obj.value, length);

	obj.value = insertComma(parseFloat(obj.value));

	return valid;
}


/**
 * 주어진 문자열의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param str    대상 문자열
 * @param length 비교 byte 수
 */
function checkLengthLE(str, length) {
	return countByte(str) <= length;
}


/**
 * 주어진 문자열의 byte 수가 length의 값과 같은지를
 * 검사하여 같으면 true를, 다르면 false를 돌려준다.
 *
 * @param obj    Text형 입력폼 객체
 * @param length 비교 byte 수
 */
function checkLengthLEObj(obj, length, fieldName) {
	if ( fieldName == undefined ) {
		fieldName = "";
	}
	else {
		fieldName += "의 ";
	}

	var valid = checkLengthLE(obj.value, length);

	if ( ! valid ) {
		alert(fieldName + "입력값이 한도를 초과하였습니다.\n\n영문 " + length + "자, 한글 " + (length / 2) + "자까지 가능합니다.");
		obj.focus();
	}

	return valid;
}


/**
 * 숫자의 정수 자릿수와 소수 자릿수를 검사하여 각 자릿수가
 * 주어진 자리수 이하인지 검사하여, 둘 다 자릿수 이하이면 0을,
 * 정수부 자릿수만 이상 있으면 1을, 소수부 자릿수만 이상있으면 2를
 * 둘 모두 이상 있으면 3을 돌려 준다. 소수부의 경우 값이 넘어오지
 * 않으면(undefined이면) 무조건 유효한 것으로 한다.
 *
 * @date   2004-01-15
 * @param  no          검사할 숫자
 * @param  intFigure   정수부 유효 자릿수
 * @param  floatFigure 소수부 유효 자릿수
 */
function checkNoFigureLE(no, intFigure, floatFigure) {
	// 컴마를 제거하고 정수부와 소수부로 나눈다.
	var no = removeChar(no, ',');

	var dotIndex = no.indexOf('.');

	var intPart   = ""; // 정수부
	var floatPart = ""; // 소수점을 포함한 소수부

	if ( dotIndex == -1 ) {
		intPart = no;
	}
	else {
		intPart   = no.substring(0, dotIndex);
		floatPart = no.substring(dotIndex);
	}

	 // 정수부 유효 여부
	var intPartValid   = intPart.length <= intFigure;

	// 소수부 유효여부
	var floatPartValid = floatFigure == undefined || trim(floatFigure) == "" || ( floatPart.length - 1 <= floatFigure);

	//alert(no + ", " + intPart + ", " + floatPart + ", " + intPartValid + ", " + floatPartValid);

	return ( intPartValid ? 0 : 1 ) + ( floatPartValid ? 0 : 2 );
}


/**
 * Text형 입력폼 값의 정수 자릿수와 소수 자릿수를 검사하여 각 자릿수가
 * 주어진 자리수 이하인지 검사하여, 둘 다 자릿수 이하이면 0을,
 * 정수부 자릿수만 이상 있으면 1을, 소수부 자릿수만 이상있으면 2를
 * 둘 모두 이상 있으면 3을 돌려 준다. 소수부의 경우 값이 넘어오지
 * 않으면(undefined이면) 무조건 유효한 것으로 한다.
 *
 * @date  2004-01-15
 * @param  obj         Text형 입력폼 객체
 * @param  intFigure   정수부 유효 자릿수
 * @param  floatFigure 소수부 유효 자릿수
 */
function checkNoFigureLEObj(obj, intFigure, floatFigure) {
	return checkNoFigureLE(obj.value, intFigure, floatFigure);
}


/* 전화번호용 지역번호 목록 */
var tpLocalNoList = [
	"02" ,
	"031", "032", "033",
	"041", "042", "043",
	"051", "052", "053", "054", "055",
	"061", "062", "063", "064"
];


/**
 * Text형 입력 폼의 값이 올바른 전화번호(핸드폰 번호가 아닌)인지 확인하여
 * 올바르면 true를, 그렇지 않으면 적절한 메세지를 뿌려주고 false를 돌려 준다.
 * 전화번호의 각 요소는 대쉬(-)로 구별된 것으로 가정한다.
 *
 * @date 2004-02-02
 * @param obj  전화번호를 입력 받는 Text형 입력폼
 */
function checkTelNoObj(obj) {
	return checkTelNo(obj.value);
}


/**
 * 주어진 값이 올바른 전화번호(핸드폰 번호가 아닌)인지 확인하여
 * 올바르면 true를, 그렇지 않으면 적절한 메세지를 뿌려주고 false를 돌려 준다.
 * 전화번호의 각 요소는 대쉬(-)로 구별된 것으로 가정한다.
 *
 * @date 2004-02-02
 * @param phoneNo  검사하려는 전화번호 값
 */
function checkTelNo(phoneNo) {
	// 빈값이면 검사하지 않는다.
	if ( trim(phoneNo) == "" ) {
		return true;
	}

	if ( isNaN(removeChar(phoneNo, '-'))) {
		alert("전화번호는 대쉬(-)와 숫자만 이용해서 입력해야 합니다.");
		return false;
	}

	// 각 요소를 자른다.
	var tempArray = phoneNo.split("-");

	if ( tempArray.length != 3 ) {
		alert("전화번호의 형식([지역번호 2,3자리]-[국번3,4자리]-[번호4자리])에 맞지 않는 값이 입력되었습니다.");
		return false;
	}

	var localNo = tempArray[0]; // 지역번호
	var areaNo  = tempArray[1]; // 국번
	var restNo  = tempArray[2]; // 기타 번호

	// 유효한 지역번호가 아니면 오류이다.
	var isExistsLocalNo = false;
	for ( var i = 0; i < tpLocalNoList.length; i++) {
		if ( localNo == tpLocalNoList[i] ) {
			isExistsLocalNo = true;
			break;
		}
	}

	if ( ! isExistsLocalNo ) {
		alert(localNo + "은(는) 현재 사용하지 않는 지역번호입니다.");
		return false;
	}

	// 국번호가 3자리에서 4자리인지 검사한다.
	if ( areaNo.length != 3 && areaNo.length != 4 ) {
		alert("국번호는 3자리나 4자리이어야 합니다.");
		return false;
	}

	// 나머지 번호를 검사한다.
	if ( restNo.length != 4 ) {
		alert("맨 뒤 번호는 4자리를 입력해야 합니다.");
		return false;
	}

	return true;
}


/* 핸드폰용 지역번호 목록 */
var hpLocalNoList = [
	"010", "011", "016", "017", "018", "019"
];

/**
 * Text형 입력 폼의 값이 올바른 핸드폰(핸드폰 번호가 아닌)인지 확인하여
 * 올바르면 true를, 그렇지 않으면 적절한 메세지를 뿌려주고 false를 돌려 준다.
 * 핸드폰 번호의 각 요소는 대쉬(-)로 구별된 것으로 가정한다.
 *
 * @date 2004-02-02
 * @param obj  핸드폰 번호를 입력 받는 Text형 입력폼
 */
function checkHpNoObj(obj) {
	return checkHpNo(obj.value);
}


/**
 * 주어진 값이 올바른 핸드폰 번호(일반 전화번호가 아닌)인지 확인하여
 * 올바르면 true를, 그렇지 않으면 적절한 메세지를 뿌려주고 false를 돌려 준다.
 * 핸드폰 번호의 각 요소는 대쉬(-)로 구별된 것으로 가정한다.
 *
 * @date 2004-02-02
 * @param phoneNo  검사하려는 핸드폰 번호값
 */
function checkHpNo(phoneNo) {
	// 빈값이면 검사하지 않는다.
	if ( trim(phoneNo) == "" ) {
		return true;
	}

	if ( isNaN(removeChar(phoneNo, '-'))) {
		alert("핸드폰 번호는 대쉬(-)와 숫자만 이용해서 입력해야 합니다.");
		return false;
	}

	// 각 요소를 자른다.
	var tempArray = phoneNo.split("-");

	if ( tempArray.length != 3 ) {
		alert("핸드폰 번호의 형식([지역번호3자리]-[국번3,4자리]-[번호4자리])에 맞지 않는 값이 입력되었습니다.");
		return false;
	}

	var localNo = tempArray[0]; // 지역번호
	var areaNo  = tempArray[1]; // 국번
	var restNo  = tempArray[2]; // 기타 번호

	// 유효한 지역번호가 아니면 오류이다.
	var isExistsLocalNo = false;
	for ( var i = 0; i < hpLocalNoList.length; i++) {
		if ( localNo == hpLocalNoList[i] ) {
			isExistsLocalNo = true;
			break;
		}
	}

	if ( ! isExistsLocalNo ) {
		alert(localNo + "은(는) 현재 사용하지 않는 지역번호입니다.");
		return false;
	}

	// 국번호가 3자리에서 4자리인지 검사한다.
	if ( areaNo.length != 3 && areaNo.length != 4 ) {
		alert("국번호는 3자리나 4자리이어야 합니다.");
		return false;
	}

	// 나머지 번호를 검사한다.
	if ( restNo.length != 4 ) {
		alert("맨 뒤 번호는 4자리를 입력해야 합니다.");
		return false;
	}

	return true;
}


/**
 * Text형 입력폼의 값이 유효한 주민등록번호 인지를
 * 점검하여 유효하면 true를 돌려주고 유효하지 않으면
 * 적절한 메세지를 보여준 다음 false를 돌려준다.
 * 파라미터인 obj2가 넘어오지 않으면 obj1에 주민등록번호
 * 전체가 담겨 있는 것으로 가정하며, obj2가 넘어오면
 * 앞 6자리는 obj1에 뒤 7자리는 obj2에 담겨 있는 것으로
 * 가정한다.
 *
 * @작성일  2004-02-05
 * @param  obj1  전체 주민등록번호 혹은 주민등록번호 
 *               앞 6자리를 담고 있는 Text형 입력폼 객체
 * @param  obj2  주민등록번호 뒤 7자리를 담고 있는 Text형 입력폼 객체
 */
function checkSSNObj(obj1, obj2) {
	var valid = true;

	if ( obj2 == undefined ) {
		valid = checkSSN(obj1.value);
	}
	else {
		valid = checkSSN(obj1.value, obj2.value);
	}

	return valid;
}

/**
 * 주민등록번호 유효성 여부를 점검하여 유효하면 true를
 * 유효하지 않으면 적절한 메세지를 보여주고 false를 돌려준다.
 * 파라미터의 갯수에 따라 그 의미가 조금 달라진다.
 * ssn2가 정의되지 않았으면, 대쉬(-)의 여부에
 * 상관없이 ssn1에 전체 주민등록번호가 담겨있는 것으로
 * 가정하고, ssn2가 정의되어 있으면 ssn1에 앞 6자리
 * ssn2에 뒤 7자리로 넘어오는 것으로 가정한다.
 *
 * @작성일  2004-02-05
 * @param  ssn1  전체 주민등록번호 혹은 주민등록번호 앞 6자리
 * @param  ssn2  주민등록번호 뒤 7자리
 */
function checkSSN(ssn1, ssn2) {
	var ssn = "";
	if ( ssn2 == undefined ) {
		ssn = ssn1;
	}
	else {
		ssn = ssn1 + "-" + ssn2;
	}

	// 주민번호의 형태와 7번째 자리(성별) 유효성 검사
	var ssnRegEx = /^\d{6}-[1234]\d{6}$/;
	if ( ! ssnRegEx.test(ssn)) {
//		alert("잘못된 주민등록번호입니다.");
		return false;
	}

	// 날짜 유효성 검사
	var birthYear = (ssn.charAt(7) <= "2") ? "19" : "20";
		birthYear += ssn.substr(0, 2);
	var birthMonth = ssn.substr(2, 2) - 1;
	var birthDate = ssn.substr(4, 2);
	var birth = new Date(birthYear, birthMonth, birthDate);

	if ( birth.getYear() % 100 != ssn.substr(0, 2)
			|| birth.getMonth() != birthMonth
			|| birth.getDate() != birthDate ) {
//		alert("잘못된 주민등록번호입니다.");
		return false;
	}

	// Check Sum 코드의 유효성 검사
	var buf = new Array(13);
	for (var i = 0; i < 6; i++) {
		buf[i] = parseInt(ssn.charAt(i));
	}

	for (var i = 6; i < 13; i++) {
		buf[i] = parseInt(ssn.charAt(i + 1));
	}

	var multipliers = [2,3,4,5,6,7,8,9,2,3,4,5];
	var sum = 0;
	for (var i = 0; i < 12; i++) {
		sum += (buf[i] *= multipliers[i]);
	}

	if ( (11 - (sum % 11) ) % 10 != buf[12] ) {
//		alert("잘못된 주민등록번호입니다.");
		return false;
	}

	return true;
}

/* String 길이 체크 by 최준영*/
function getLength(str) {
	return(str.length+(escape(str)+"%u").match(/%u/g).length-1);
}


/* Email 정규식 체크 by 한승훈*/
function isEmail(s){
	return s.search(/^\s*[\w\~\-\.]+\@[\w\~\-]+(\.[\w\~\-]+)+\s*$/g)>=0;
}


/* 이미지 파일 확장명 제한 하기 */
function fileLimit(file) {
extArray = new Array("gif", "jpg", "png"); // 확장명 선언
var allow = false;
if(file)
{
		/*
		while (file.indexOf("\\") != -1)
		file = file.slice(file.indexOf("\\") + 1);
		ext = file.slice(file.indexOf(".")).toLowerCase();
		*/

		ext = file.substring(file.lastIndexOf(".")+1,file.length).toLowerCase();

		for (var i = 0; i < extArray.length; i++)
		{
			if (extArray[i] == ext)
			{
				allow=true; break;
			}
		}

		return allow;
	}
return allow;
}