* String 을 English에서 Korean charset으로 디코딩
   new String(str.getBytes("8859_1"), "KSC5601");
   new String(str.getBytes("8859_1"), "euc-kr")

 
 
 
 
package audit.common;
import java.text.*;
import java.util.*;
import java.rmi.*;
import javax.servlet.http.*;
import java.sql.*;
import javax.naming.*;
import javax.sql.*;
import com.oreilly.servlet.MultipartRequest;
import com.oreilly.servlet.multipart.DefaultFileRenamePolicy;
public class Utility extends SysDate
{
    private static Utility instance = null;
    private Properties p;
    private boolean bKoreanToEnglish;
    private boolean jspKoreanToEnglish;
    public Utility()
    {}
    /** 문자열의 오른쪽의 스페이스를 없애서 문자열을 리턴한다.
     *   @param  s 대상문자열
     *   @return 공백을 없앤 문자열
     */
    public String rTrim(String s)
    {
        String sRtn = null;
        String sChar = null;
        int iLen = s.length();
        for (int i = 0; i < iLen; i++)
        {
            sChar = s.substring(i, i + 1);
            if (sChar.equals(" "))
            {
                sRtn = s.substring(i + 1, iLen);
            }
            else
            {
                break;
            }
        }
        return sRtn;
    }
    /** 문자열의 왼쪽의 스페이스를 없애서 문자열을 리턴한다.
     *   @param  s 대상문자열
     *   @return  공백을 없앤 문자열
     */
    public String lTrim(String s)
    {
        return "";
    }
    /** 문자열 내부의 스페이스를 없애서 문자열을 리턴한다.
     *   @param  s 대상문자열
     *   @return  공백을 없앤 문자열
     */
    public String mTrim(String s)
    {
        String sRtn = null;
        sRtn = s.trim();
        return sRtn;
    }
    /**
     * 금액문자열을 금액표시타입으로 변환한다. <BR>
     * (예) 12345678 --> 12,345,678          <BR>
     * @param    moneyString 금액문자열.
     * @return   금액.
     */
    public String makeMoneyType(String moneyString)
    {
        DecimalFormat df = new DecimalFormat();
        DecimalFormatSymbols dfs = new DecimalFormatSymbols();
        dfs.setGroupingSeparator(',');
        df.setGroupingSize(3);
        df.setDecimalFormatSymbols(dfs);
        return (df.format(Double.parseDouble(moneyString))).toString();
    }
    /**
     * 금액문자열을 금액표시타입으로 변환한다. <BR>
     * (예) 12345678 --> 12,345,678            <BR>
     * @param    moneyString 금액 .
     * @return   금액
     */
    public String makeMoneyType(int intMoneyString)
    {
        String moneyString = new Integer(intMoneyString).toString();
        DecimalFormat df = new DecimalFormat();
        DecimalFormatSymbols dfs = new DecimalFormatSymbols();
        dfs.setGroupingSeparator(',');
        df.setGroupingSize(3);
        df.setDecimalFormatSymbols(dfs);
        return (df.format(Double.parseDouble(moneyString))).toString();
    }
    /**
     * 금액표시타입을 금액문자열로 변환한다. <BR>
     * (예) 12,345,678 --> 12345678          <BR>
     * @param    moneyString 금액표시문자열.
     * @return   금액문자열.
     */
    public String makeNoMoneyType(String moneyString)
    {
        StringTokenizer st = new StringTokenizer(moneyString, ",");
        String out = "";
        String temp = null;
        while (st.hasMoreTokens())
        {
            temp = st.nextToken();
            out = out + temp;
        }
        return out;
    }
    /**
     * String을 int값으로 변환한다.           <BR>
     *
     * @param    str     int값으로 변환될 String문자열.
     * @return   변환된 int 값.
     */
    public int stoi(String str)
    {
        if (str == null)
        {
            return 0;
        }
        return (Integer.valueOf(str).intValue());
    }
    /**
     * int값을 String으로 변환한다.           <BR>
     *
     * @param    i   String으로 변환될 int 값.
     * @return   변환된 String 값.
     */
    public String itos(int i)
    {
        return (new Integer(i).toString());
    }
    /**
     * 문자열을 치환
     * @param src 대상글
     * @param from 변경할 문자
     * @param to 변경될 문자
     * @return 변경된 이후 문자
     */
    public String replace(String src, String from, String to) throws Exception
    {
        if (src == null)
        {
            return null;
        }
        if (from == null)
        {
            return src;
        }
        if (to == null)
        {
            to = "";
        }
        StringBuffer buf = new StringBuffer();
        for (int pos; (pos = src.indexOf(from)) >= 0; )
        {
            buf.append(src.substring(0, pos));
            buf.append(to);
            src = src.substring(pos + from.length());
        }
        buf.append(src);
        return buf.toString();
    }
    /**
     * 일정한 길이로 문자를 자름
     * @param str 자를 문자
     * @param limit 자를 수
     * @return 변경된 이후 문자
     */
    public String cutString(String str, int limit)
    {
        if (str == null)
        {
            return str;
        }
        int len = str.length();
        int cnt = 0, index = 0;
        while (index < len && cnt < limit)
        {
            if (str.charAt(index++) < 256) // 1바이트 문자라면...
            {
                cnt++; // 길이 1 증가
            }
            else // 2바이트 문자라면...
            {
                cnt += 2; // 길이 2 증가
            }
        }
        if (index < len)
        {
            str = str.substring(0, index) + "...";
        }
        return str;
    }
    /**
     * 두개의 문자열을 비교하여 같은 문자열이면 true, 다른 문자열이면 false를 리턴한다.
     * @param sOne 비교할 문자열1
     * @param sOne 비교할 문자열2
     * @return 같은 문자열이면 true, 다른 문자열이면 false
     */
    public boolean stringCompare(String sOne, String sTwo)
    {
        if (sOne == null && sTwo == null)
        {
            return true;
        }
        if (sOne == null && sTwo != null)
        {
            return false;
        }
        if (sOne != null && sTwo == null)
        {
            return false;
        }
        return sOne.equals(sTwo);
    }
    /**
     * 실수를 지정된 소수점 자리까지만 취하고 리턴하는 메소드
     * @param f 대상 float형 자료
     * @param num 소수점이하 자리수
     * @return 지정된 소수점 자리까지잘린 실수 <br><br>
       <b>기타 :</b> 반올림 아님 예) roundCutFloat(33.236f , 2) => 33.23
     */
    public float roundCutFloat(float f, int num)
    {
        String sTargetFloat = Float.toString(f);
        StringTokenizer stk = new StringTokenizer(sTargetFloat, ".");
        String sIntPart = stk.nextToken();
        String sFloPart = stk.nextToken();
        if (num > sFloPart.length())
        {
            return f;
        }
        else
        {
            sFloPart = sFloPart.substring(0, num);
            String sReturnFloat = sIntPart + "." + sFloPart;
            return Float.parseFloat(sReturnFloat);
        }
    }
    /**
     * double형 실수를 지정된 소수점 자리까지만 취하고 리턴하는 메소드
     * @param d 대상 double형 자료
     * @param num 소수점이하 자리수
     * @return 지정된 소수점 자리까지잘린 double형 실수 <br><br>
       <b>기타 :</b> 반올림 아님 예) roundCutFloat(33.236 , 2) => 33.23
     */
    public double roundCutDouble(double d, int num)
    {
        double decimalPosition = Math.pow(10D, num);
        double ReturnValue = Math.floor(d * decimalPosition) / decimalPosition;
        return ReturnValue;
    }
    /**
     * 실수를 지정된 소수점 자리까지만 반올림하여 리턴한다.
     * @param f 대상 float형 자료
     * @param position 소수점이하 자리수
     * @return 지정된 소수점 자리까지 반올림한 실수 <br><br>
       <b>기타 :</b> 예) roundHalfFloat(33.236 , 2) => 33.24
     */
    public float roundHalfFloat(float f, int position)
    {
        double decimalPosition = Math.pow(10D, position);
        float ReturnValue = (float) ( (double) Math.round( (double) f *
            decimalPosition) / decimalPosition);
        return ReturnValue;
    }
    /**
     * double형 실수를 지정된 소수점 자리까지만 반올림하여 리턴한다.
     * @param d 대상 double형 자료
     * @param position 소수점이하 자리수
     * @return 지정된 소수점 자리까지 반올림한 double형 실수 <br><br>
       <b>기타 :</b> 예) roundHalfDouble(33.236 , 2) => 33.24
     */
    public double roundHalfDouble(double d, int position)
    {
        double decimalPosition = Math.pow(10D, position);
        double ReturnValue = (double) Math.round(d * decimalPosition) /
            decimalPosition;
        return ReturnValue;
    }
    /**
     * 실수를 지정된 소수점 자리까지만 올림하여 리턴한다.
     * @param f 대상 float형 자료
     * @param position 소수점이하 자리수
     * @return 지정된 소수점 자리까지 올림한 실수 <br><br>
       <b>기타 :</b> 예) roundAllFloat(33.231 , 2) => 33.24
     */
    public float roundAllFloat(float f, int position)
    {
        double decimalPosition = Math.pow(10D, position);
        float ReturnValue = (float) (Math.ceil( (double) f * decimalPosition) /
                                     decimalPosition);
        return ReturnValue;
    }
    /**
     * double형 실수를 지정된 소수점 자리까지만 올림하여 리턴한다.
     * @param d 대상 double형 자료
     * @param position 소수점이하 자리수
     * @return 지정된 소수점 자리까지 올림한 double형 실수 <br><br>
       <b>기타 :</b> 예) roundAllDouble(33.231 , 2) => 33.24
     */
    public double roundAllDouble(double d, int position)
    {
        double decimalPosition = Math.pow(10D, position);
        double dRtn = Math.ceil(d * decimalPosition) / decimalPosition;
        return dRtn;
    }
    /**
     * 숫자를 해당 자릿수 만큼 앞에 0을 붙여 스트링으로 리턴하는 메소드
     * @param original 대상 정수
     * @param digit 전체 자리수
     * @return 변형된 문자열 <br><br>
       <b>기타 :</b> 예) toLeadingZeroString(223,5) => "00223"
     */
    public String toLeadingZeroString(int original, int digit)
    {
        String result = "";
        String tr = Integer.toString(original);
        for (int i = 1; i <= digit - tr.length(); i++)
        {
            result = result + "0";
        }
        return result + tr;
    }
    /**
     * NULL을 빈문자열("")로 리턴한다.
     * @param str null을 체크할 문자열
     * @return 널여부를 체크한 문자열 <br><br>
     */
    public String nullToEmptyString(String str)
    {
        if (str == null)
        {
            return "";
        }
        if ("null".equals(str))
        {
            return "";
        }
        else
        {
            return str.trim();
        }
    }
    /**
     * 문자를 substring 할때 해당 target 문자가 null일경우 substring 하지않고 ""으로 리턴하는 메쏘드
     * @param str 원본 문자열
     * @param beginIndex substring할 첫번째 인덱스
     * @return 널여부를 체크한 문자열 <br><br>
       <b>기타 :</b> 예) toSubString("abcd" , 2) => "cd"
     */
    public String toSubString(String str, int beginIndex)
    {
        String ret = null;
        String str_temp = null;
        str_temp = nullToEmptyString(str);
        if ("".equals(str_temp))
        {
            return str_temp;
        }
        else
        {
            ret = str.substring(beginIndex);
            return ret;
        }
    }
    /**
     * 문자를 substring 할때 해당 target 문자가 null일경우 substring 하지않고 ""으로 리턴하는 메쏘드
     * @param str 원본 문자열
     * @param beginIndex substring할 첫번째 인덱스
     * @param endIndex substring할 마지막 인덱스
     * @return 널여부를 체크한 문자열 <br><br>
       <b>기타 :</b> 예) toSubString("abcd" , 2,3) => "d"
     */
    public String toSubString(String str, int beginIndex, int endIndex)
    {
        String ret = null;
        String str_temp = null;
        str_temp = nullToEmptyString(str);
        if ("".equals(str_temp))
        {
            return str_temp;
        }
        else
        {
            ret = str.substring(beginIndex, endIndex);
            return ret;
        }
    }
    /**
     * String 을 English에서 Korean charset으로 디코딩
     * @param str 원본 문자열
     * @return Korean charset으로 디코딩된 문자열 <br><br>
     */
    public String EnglishToKorean(String str)
    {
        try
        {
            if (str == null)
            {
                return null;
            }
            else
            {
                return new String(str.getBytes("8859_1"), "KSC5601");
            }
        }
        catch (Exception e)
        {
            System.out.println("Error on EnglishToKorean");
        }
        return null;
    }
    /**
     * String 을 Korean에서 English charset으로 디코딩
     * @param str 원본 문자열
     * @return English charset으로 디코딩된 문자열 <br><br>
     */
    public String KoreanToEnglish(String str)
    {
        try
        {
            if (str == null)
            {
                return null;
            }
            else
            {
                return new String(str.getBytes("KSC5601"), "8859_1");
            }
        }
        catch (Exception e)
        {
            System.out.println("Error on KoreanToEnglish");
        }
        return null;
    }
    /**
     * double 형태중 9.0E9 를 900000000 식으로 나타내는 함수
     * @param dParam 원본 double형
     * @return String string형문자 <br><br>
     */
    public String doubleChangeString(double dParam)
    {
        String sRtn = null;
        NumberFormat nf = NumberFormat.getInstance();
        return nf.format(dParam);
    }
    /**
     * textArea의 Data를 HTML 내의 Table에 보여주고자 할 때 특수문자 처리하는 메소드
     * \n를 "\, " \"를 "\"", <를 "\<", >를 "\>", 공백를 "\ ", &를 "\&" 로 변환
     * 입력받은 스트링이 null인 경우 Empty String("") 리턴
     * @param str 원본 문자열
     * @return String 변환된 문자열<br><br>
     */
    public String textAreaToPage(String str)
    {
        int maxwidth = 100;
        String ret = "";
        int endindex = 0;
        str = nullToEmptyString(str);
        if ("" != str)
        {
            endindex = str.indexOf('\n');
            if (endindex != str.length())
            {
                for (endindex = 0; endindex >= 0; )
                {
                    endindex = str.indexOf('\n');
                    if (endindex != -1)
                    {
                        if (endindex > maxwidth)
                        {
                            ret = ret + str.substring(0, maxwidth) + "<br>";
                            str = str.substring(maxwidth, str.length());
                            endindex -= maxwidth;
                        }
                        else
                        {
                            ret = ret + str.substring(0, endindex - 1) + "<br>";
                            str = str.substring(endindex + 1, str.length());
                        }
                    }
                }
                str = ret + str;
            }
        }
        return str;
    }
    /**
     * 한 String에 원하는 문자가 몇 개 포함되어 있는지 파악하는 method
     * @param str 비교하려는 문장
     * @param str 찾으려는 문자
     * @return String 변환된 문자열<br><br>
     */
    public int charCounter(String str, String delim)
    {
        int indx = 0;
        int icount = 0;
       
        if(nullToEmptyString(delim).equals(""))
     {
      return 0;
     }
     else
     {
         for (indx = str.indexOf(delim); indx != -1; )
         {
             str = str.substring(str.indexOf(delim) + 1, str.length());
             indx = str.indexOf(delim);
             icount++;
         }
  }
 
        return icount;
    }

    /**
     * 한 String에 원하는 특수문자가 몇 개 포함되어 있는지 파악하는 method
     * @param str 비교하려는 문장
     * @param str 찾으려는 문자
     * @return String 변환된 문자열<br><br>
     */
    public int specialCharCounter(String str, String delim)
    {
        int indx = 0;
        int icount = 0;
        StringTokenizer st = null;
       
        if(nullToEmptyString(str).equals(""))
     {
      return 0;
     }
     else
     {
      st = new StringTokenizer(str, delim);
         while (st.hasMoreTokens())
         {
          st.nextToken();
             icount++;
         }
  }
 
        return icount;
    }
    /**
     * 문자가 null,"","null" 인 경우 해당 문자를 0으로 채워주는 메소드
     * @param str 비교하려는 문장
     * @return String 문자열<br><br>
     */
    public String nullToZero(String str)
    {
        String returnCheck = null;
        if (stringCompare("", str) || stringCompare("null", str) || str == null)
        {
            returnCheck = "0";
        }
        else
        {
            returnCheck = str;
        }
        return returnCheck;
    }
    /**
     * 문자열에서 해당 문자로 문자열을 잘라서 배열로 리턴하는 메소드
     * @param s 대상문자열
     * @param token 자르려는 문자
     * @return string[] 문자열배열<br><br>
     */
    public String[] cutTokenToArray(String s, String token) throws
        RemoteException
    {
        StringTokenizer stz = new StringTokenizer(s, token);
        String result[] = new String[stz.countTokens()];
        try
        {
            for (int j = 0; j < result.length; j++)
            {
                result[j] = stz.nextToken();
            }
        }
        catch (Exception exception)
        {
            System.out.println(exception.getMessage());
        }
        return result;
    }

    public String getProgramName(Object oProgramName, String sGubun)
    {
        String sName = null;
        String sReturn = null;
        int iLast = 0;
        try
        {
            if ("J" == sGubun)
            {
                sName = oProgramName.getClass().getName();
                iLast = sName.lastIndexOf(".");
                sReturn = sName.substring(iLast + 2) + ".jsp";
            }
            else if ("B" == sGubun)
            {
                StringTokenizer stBean = new StringTokenizer(oProgramName.
                    getClass().getName());
                String sOneBean = stBean.nextToken(".");
                String sTwoBean = stBean.nextToken(".");
                String sThreeBean = stBean.nextToken(".");
                String sFourBean = stBean.nextToken(".");
                String sFiveBean = stBean.nextToken(".");
                String sSixBean = stBean.nextToken(".");
                sReturn = sSixBean + ".java";
            }
            else
            {
                sReturn = "";
            }
        }
        catch (Exception ex)
        {
            System.out.println("Error  getProgramName ");
        }
        return sReturn;
    }
    /**
     * 파라미터로 받은 값을 null 또는 해당 String으로 리턴하는 메소드
     * @param request request객체
     * @param sParameterName 받고자하는 Parameter 이름
     * @return string null객체,null문자,Empty String은 null객체로 리턴 <br>
               정상적인 String은 trim()하고 리턴 <br><br>
     */
    public String getCheckParameter(HttpServletRequest request,
                                    String sParameterName)
    {
        String sCheckParameter = request.getParameter(sParameterName);
        if (jspKoreanToEnglish)
        {
           sCheckParameter = EnglishToKorean(sCheckParameter);
        }
        if (sCheckParameter == null || "null".equals(sCheckParameter) ||
            sCheckParameter.trim().length() == 0)
        {
            return null;
        }
        else
        {
            return sCheckParameter.trim();
        }
    }
    /**
     * 파라미터로 받은 값을 null 또는 해당 String으로 리턴하는 메소드
     * @param request request객체
     * @param sParameterName 받고자하는 Parameter 이름
     * @return string배열<br><br>
     */
    public String[] getCheckParameterValues(HttpServletRequest request,
                                            String sParameterName)
    {
        String sCheckParameterArray[] = request.getParameterValues(
            sParameterName);
        if (getLength(sCheckParameterArray) == 0)
        {
            return null;
        }
        String sReturn[] = new String[getLength(sCheckParameterArray)];
        for (int i = 0; i < getLength(sCheckParameterArray); i++)
        {
            if (bKoreanToEnglish)
            {
                sReturn[i] = EnglishToKorean(sCheckParameterArray[i]);
            }
            else
            {
                sReturn[i] = sCheckParameterArray[i];
            }
        }
        return sReturn;
    }
   
    /**
     * 파라미터로 받은 값을 null 또는 해당 String으로 리턴하는 메소드
     * @param multi MultipartRequest
     * @param sParameterName 받고자하는 Parameter 이름
     * @return string null객체,null문자,Empty String은 null객체로 리턴 <br>
               정상적인 String은 trim()하고 리턴 <br><br>
     */
    public String getCheckParameterMulti(MultipartRequest multi,
                                    String sParameterName)
    {
        String sCheckParameter = multi.getParameter(sParameterName);
        if (jspKoreanToEnglish)
        {
           sCheckParameter = EnglishToKorean(sCheckParameter);
        }
        if (sCheckParameter == null || "null".equals(sCheckParameter) ||
            sCheckParameter.trim().length() == 0)
        {
            return null;
        }
        else
        {
            return sCheckParameter.trim();
        }
    }
    /**
     * 파라미터로 받은 값을 null 또는 해당 String으로 리턴하는 메소드
     * @param request request객체
     * @param sParameterName 받고자하는 Parameter 이름
     * @return string배열<br><br>
     */
    public String[] getCheckParameterValuesMulti(MultipartRequest multi,
                                            String sParameterName)
    {
        String sCheckParameterArray[] = multi.getParameterValues(
            sParameterName);
        if (getLength(sCheckParameterArray) == 0)
        {
            return null;
        }
        String sReturn[] = new String[getLength(sCheckParameterArray)];
        for (int i = 0; i < getLength(sCheckParameterArray); i++)
        {
            if (bKoreanToEnglish)
            {
                sReturn[i] = EnglishToKorean(sCheckParameterArray[i]);
            }
            else
            {
                sReturn[i] = sCheckParameterArray[i];
            }
        }
        return sReturn;
    }
    /**
     * 파라미터로 받은 값을 0 또는 해당 integer로 리턴하는 메소드
     * @param request request객체
     * @param sParameterName 받고자하는 Parameter 이름
     * @return int값<br><br>
     */
    public int getCheckIntParameter(HttpServletRequest request,
                                    String sParameterName)
    {
        String sCheckParameter = request.getParameter(sParameterName);
        if (sCheckParameter == null || "null".equals(sCheckParameter) ||
            sCheckParameter.trim().length() == 0)
        {
            return 0;
        }
        else
        {
            return Integer.parseInt(sCheckParameter.trim());
        }
    }
    /**
     * 파라미터로 받은 값을 0.0 또는 해당 double로 리턴하는 메소드
     * @param request request객체
     * @param sParameterName 받고자하는 Parameter 이름
     * @return double값<br><br>
     */
    public double getCheckDoubleParameter(HttpServletRequest request,
                                          String sParameterName)
    {
        String sCheckParameter = request.getParameter(sParameterName);
        if (sCheckParameter == null || "null".equals(sCheckParameter) ||
            sCheckParameter.trim().length() == 0)
        {
            return 0.0;
        }
        else
        {
            return Double.parseDouble(sCheckParameter.trim());
        }
    }
    /**
     * String, long[], double[], String[], String[][](첫번째 기준열), Object[]의 length를 구함
     * @param request request객체
     * @param sParameterName 받고자하는 Parameter 이름
     * @return int배열값<br><br>
     */
    public int getLength(Object oValue)
    {
        int iValue = 0;
        if (oValue instanceof String)
        {
            String one = (String) oValue;
            if ( (String) oValue == null)
            {
                return iValue;
            }
            else
            {
                return one.length();
            }
        }
        if (oValue instanceof String[])
        {
            String two[] = (String[]) oValue;
            if ( (String[]) oValue == null)
            {
                return iValue;
            }
            else
            {
                return two.length;
            }
        }
        if (oValue instanceof String[][])
        {
            String three[][] = (String[][]) oValue;
            if ( (String[][]) oValue == null)
            {
                return iValue;
            }
            else
            {
                return three.length;
            }
        }
        else
        {
            return iValue;
        }
    }
    public String getCDInSelectBoxWithCon(Connection conn, String sSelectName, String sDefaultSelect,
                                   String sDefaultCap, String sChangeEvent,
                                   String sSql) throws Exception
    {
        StringBuffer sSelectBox = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sDefaultSelected = "";
        String sSelected = "";
        try
        {
            // Sql문 작성
            //파라메터 세팅한다.
            ps = conn.prepareStatement(sSql);
            rs = ps.executeQuery();
            sSelectBox = new StringBuffer();
            if (!sChangeEvent.equals(""))
            {
                sSelectBox.append("<select name='" + sSelectName +
                                  "' omChange=" + sChangeEvent + " omKeyDown=cfMoveTabIndex()>");
            }
            else
            {
                sSelectBox.append("<select name='" + sSelectName + "' omKeyDown=cfMoveTabIndex()>");
            }
            if (sDefaultSelect.equals(""))
            {
                sDefaultSelected = "selected";
            }
            else
            {
                sSelected = "selected";
            }
            if (!sDefaultCap.equals(""))
            {
                sSelectBox.append("<option value='' " + sDefaultSelected + ">" +
                                  sDefaultCap + "</option>");
            }
            while (rs.next())
            {
                if (!sDefaultSelected.equals("selected") &&
                    rs.getString("CD").equals(sDefaultSelect))
                {
                    sSelectBox.append("<option value='" + rs.getString("CD") +
                                      "' selected >" + rs.getString("CD_NM") +
                                      "</option>");
                }
                else
                {
                    sSelectBox.append("<option value='" + rs.getString("CD") +
                                      "'>" + rs.getString("CD_NM") +
                                      "</option>");
                }
            }
            sSelectBox.append("</select>");
        }
        catch (Exception ex)
        {
            System.out.println(ex.getMessage());
        }
        finally
        {
            try
            {
                if (rs != null)
                {
                    rs.close();
                }
                if (ps != null)
                {
                    ps.close();
                }
            }
            catch (Exception ex)
            {
                System.out.println(ex.getMessage());
            }
        }
        return sSelectBox.toString();
    }
    public String getCDInSelectBox(String sSelectName, String sDefaultSelect,
                                   String sDefaultCap, String sChangeEvent,
                                   String sSql) throws Exception
    {
        StringBuffer sSelectBox = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        Connection conn = null;
        String sDefaultSelected = "";
        String sSelected = "";
        try
        {
            conn = CmJDBCConnection.getConnection();
            System.out.println("Connection 연결");
            // Sql문 작성
            //파라메터 세팅한다.
            ps = conn.prepareStatement(sSql);
            rs = ps.executeQuery();
            sSelectBox = new StringBuffer();
            if (!sChangeEvent.equals(""))
            {
                sSelectBox.append("<select name='" + sSelectName +
                                  "' omChange=" + sChangeEvent + " omKeyDown=cfMoveTabIndex()>");
            }
            else
            {
                sSelectBox.append("<select name='" + sSelectName + "' omKeyDown=cfMoveTabIndex()>");
            }
            if (sDefaultSelect.equals(""))
            {
                sDefaultSelected = "selected";
            }
            else
            {
                sSelected = "selected";
            }
            if (!sDefaultCap.equals(""))
            {
                sSelectBox.append("<option value='' " + sDefaultSelected + ">" +
                                  sDefaultCap + "</option>");
            }
            while (rs.next())
            {
                if (!sDefaultSelected.equals("selected") &&
                    rs.getString("CD").equals(sDefaultSelect))
                {
                    sSelectBox.append("<option value='" + rs.getString("CD") +
                                      "' selected >" + rs.getString("CD_NM") +
                                      "</option>");
                }
                else
                {
                    sSelectBox.append("<option value='" + rs.getString("CD") +
                                      "'>" + rs.getString("CD_NM") +
                                      "</option>");
                }
            }
            sSelectBox.append("</select>");
        }
        catch (Exception ex)
        {
            System.out.println(ex.getMessage());
        }
        finally
        {
            try
            {
                if (rs != null)
                {
                    rs.close();
                }
                if (ps != null)
                {
                    ps.close();
                }
                if (conn != null)
                {
                    conn.close();
                }
            }
            catch (Exception ex)
            {
                System.out.println(ex.getMessage());
            }
        }
        return sSelectBox.toString();
    }
//////////////////// Made by Shin woochoul
    public HashMap requestDataProcessing(HttpServletRequest req)
    {
        HashMap insertMap = new HashMap();
        HashMap updateMap = new HashMap();
        HashMap deleteMap = new HashMap();
        HashMap selectMap = new HashMap();
        System.out.println("######################################");
        String command = req.getParameter("hiddenWorkGubn"); // insert,update,delete,select
        System.out.println("Utility- :command :" + command);
        System.out.println("######################################");
        if (command.equals("insert"))
        {
            insertMap = getData(req);
        }
        else if (command.equals("update"))
        {
            updateMap = getData(req);
//System.out.println("UU------------" + updateMap.toString() );
        }
        else if (command.equals("delete"))
        {
            deleteMap = getData(req);
        }
        else
        {
            selectMap = getData(req);
        }
        HashMap crudMap = new HashMap(4);
        crudMap.put("insert", insertMap);
        crudMap.put("update", updateMap);
        crudMap.put("delete", deleteMap);
        crudMap.put("select", selectMap);
        return crudMap;
    }
    /**
     * @param req Client에서 받은 Request정보
     * @param row Client에서 받은 리스트의 row 개수
     * @return map Request 로 받은 정보
     */
    public HashMap getData(HttpServletRequest req)
    {
        System.out.println("22######################################getData1");
        HashMap map = new HashMap(req.getParameterMap());
        System.out.println("22######################################getData2" +
                           map);
        return map;
    }
 
    public String specialLetterChange(String str)
    {
        String sRtn = "";
       sRtn = str.replaceAll("\n", "\\\\n");
       sRtn = sRtn.replaceAll("\r", "\\\\r");
       sRtn = sRtn.replaceAll( "'", "\\\\'");
       sRtn = sRtn.replaceAll( "\"", "\\\\\"");
     return sRtn;
    }
    /**
     * @param length 보여줄 문자열의 길이
     * @param str    원문자열
     * @return TargetStr 보여줄문자열길이+... 더해진 문자열
     */
 public String StringToDot(int length, String str)
 {
  String TempStr = null;
  if(str.length() < length)
  {
   TempStr = str;
  }
  else
  {
   TempStr = (String)(str).substring(0, length) + "...";
  }
  return TempStr;
 }
///////////////////////////////////////////
}