using System;
using System.Text;
using System.IO;
using System.Data;
using System.Drawing;
using System.Windows.Forms;
using System.Media;
using System.Threading;

using Microsoft.Speech.Synthesis;
using ICSharpCode.SharpZipLib.Zip;
using ICSharpCode.SharpZipLib.Zip.Compression.Streams;
using System.Runtime.InteropServices;
using Cosmos.UserFrame;

/*-----------------------------------------------------------------------------------------------*/
// 설      명 : 공통 모듈
// 작  성  자 : 
// 변경  이력 : 
/*-----------------------------------------------------------------------------------------------*/
namespace Cosmos.Common
{
    /// <summary>
    /// Common Utility 
    /// </summary>
    public class CmUtil : UsUtil
    {
        [DllImport("Sensapi.dll")]
        private static extern int IsNetworkAlive(ref int dwFlags);

        //private static int NETWORK_LAN = 0x01;           // 랜 카드 신호 유무
        //private static int NETWORK_WAN = 0x02;           // WAN 관련 유무
        //private static int NETWORK_AOL = 0x04;           // 랜 카드 AOL 신호 유무


        ///// <summary>
        ///// 수량 표시형식으로 변환
        ///// </summary>
        ///// <param name="sQty"></param>
        ///// <returns></returns>
        //public static string NumToQty(string sQty)
        //{
        //    try
        //    {
        //        if (sQty.Trim().Length > 0)
        //        {
        //            return NumToQty((long)double.Parse(sQty.Trim()));
        //        }
        //    }
        //    catch { }
        //    return "0";
        //}

        ///// <summary>
        ///// 수량 표시형식으로 변환
        ///// </summary>
        ///// <param name="nQty"></param>
        ///// <returns></returns>
        //public static string NumToQty(long nQty)
        //{
        //    try
        //    {
        //        return String.Format("{0:N0}", nQty);
        //    }
        //    catch { }
        //    return "0";
        //}

        /// <summary>
        /// 문자열의 숫자(Long)로 변환 - 글로벌 금액표시 문자열 변환에 사용하면 안됨
        /// </summary>
        /// <param name="sValue"></param>
        /// <returns></returns>
        public static long LongParse(string sValue)
        {
            try
            {
                if (sValue.Trim().Length > 0)
                {
                    return (long)DoubleParse(sValue);
                }
            }
            catch { }

            return 0;
        }
        /// <summary>
        /// 문자열의 숫자(Int)로 변환 - 글로벌 금액표시 문자열 변환에 사용하면 안됨
        /// </summary>
        /// <param name="sValue"></param>
        /// <returns></returns>
        public static int IntParse(string sValue)
        {
            try
            {
                if (sValue.Trim().Length > 0)
                {
                    return (int)DoubleParse(sValue);
                }
            }
            catch { }

            return 0;
        }

        /// <summary>
        /// 문자열의 숫자(Double)로 변환 - 글로벌 금액표시 문자열 변환에 사용하면 안됨
        /// </summary>
        /// <param name="sValue"></param>
        /// <returns></returns>
        public static double DoubleParse(string sValue)
        {
            double dValue = 0;
            try
            {
                if (sValue.Trim().Length > 0)
                {
                    dValue = double.Parse(sValue.Trim());
                }
            }
            catch { }

            return dValue;
        }
        
        /// <summary>
        /// 시간변환(HHMMSS => HH:MM:SS)
        /// </summary>
        /// <param name="sTimeStr"></param>
        /// <returns></returns>
        public static string StrToTime(string sTimeStr)
        {
            try
            {
                string sTime = sTimeStr.Replace(":", "").Trim();
                if (sTime.Length == 6)
                {
                    return sTime.Substring(0, 2) + ":" + sTime.Substring(2, 2) + ":" + sTime.Substring(4, 2);
                }
                else if (sTime.Length == 4)
                {
                    return sTime.Substring(0, 2) + ":" + sTime.Substring(2, 2);
                }
            }
            catch { }

            return "";
        }

        /// <summary>
        /// Round Up, Round Off, Round Down Calculation(올림 반올림 버림 계산)
        /// </summary>
        /// <param name="Value">Calculated(계산)</param>
        /// <param name="Type">0:Round Up(올림) 1: Round Off(반올림) 2: Round Down(버림)</param>
        /// <param name="Digits">Digit Number(자릿수)</param>
        /// <returns></returns>
        public static double MathRounds(double Value, string Type, int Digits)
        {
            double Sum = 0;

            try
            {
                double n = Math.Pow(10.0, Digits);

                switch (Type)
                {
                    case PosConst.MATH_ROUND.CEILING:   //Round Up(올림)
                        Sum = CmUtil.DoubleDivision(Math.Ceiling(CmUtil.DoubleMultiplication(Value, n)), n);
                        break;
                    case PosConst.MATH_ROUND.ROUND:     //Round Off(반올림)
                        //#20171109 반올림 계산시 5인 경우 올림이 되지 않고 내림이 됨 start
                        //기존
                        Sum = CmUtil.DoubleDivision(Math.Round(CmUtil.DoubleMultiplication(Value, n)), n);
                        //변경
                        //Sum = CmUtil.DoubleDivision(Math.Round(CmUtil.DoubleMultiplication(Value, n), MidpointRounding.AwayFromZero), n);
                        //#20171109 반올림 계산시 5인 경우 올림이 되지 않고 내림이 됨 end
                        //Sum = Math.Round(Value, Digits, MidpointRounding.AwayFromZero);
                        break;
                    case PosConst.MATH_ROUND.TRANCATE: //Round Down(버림)
                        Sum = CmUtil.DoubleDivision(Math.Truncate(CmUtil.DoubleMultiplication(Value, n)), n);
                        break;
                    default:
                        break;
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return Sum;
        }

        /// <summary>
        /// Cut as many as designated No. of digits.(지정한 자리만큼 절사한다.)
        /// </summary>
        /// <param name="pAmt">AMOUNT(금액)</param>
        /// <param name="pPos">No. of Cut Digits(절사 자리수)</param>
        /// <param name="cut_Amt"> The amount of No. of Cut(절사된 금액)</param>
        /// <returns></returns>
        public static double AmountCut(double Amt, int Digits, out double cut_Amt)
        {
            double n = Math.Pow(10.0, Digits);
            double Sum = 0;
            cut_Amt = 0.0;
            try
            {
                Sum = DoubleDivision(Math.Truncate(DoubleMultiplication(Amt, n)), n);
                cut_Amt = DoubleSubtraction(Amt, Sum);
            }
            catch (Exception ex)
            {
                Sum = Amt;
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return Sum;

        }
        public static double AmountCut(double Amt, int Digits)
        {
            double cut_Amt;

            return AmountCut(Amt, Digits, out cut_Amt);
        }

        /// <summary>
        /// 율 금액 계산
        /// </summary>
        /// <param name="nValue"></param>
        /// <param name="dPercent"></param>
        /// <returns></returns>
        public static double MathAmtPercent(double nValue, double dPercent)
        {
            try
            {
                return DoubleMultiplication(nValue, (dPercent / 100.00));
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return 0;
        }

        /// <summary>
        /// Double Type Add (더블형 더하기)
        /// </summary>
        /// <param name="Sum1">Calculation Value1(계산값1)</param>
        /// <param name="Sum2">Calculation Value1(계간값2)</param>
        /// <returns>Result Value(결과값)</returns>
        public static double DoubleAdd(double Sum1, double Sum2)
        {
            decimal Sum = 0;
            try
            {
                Sum = Convert.ToDecimal(Sum1) + Convert.ToDecimal(Sum2);
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return Convert.ToDouble(Sum);
        }

        /// <summary>
        /// Double Type Subtraction (더블형 빼기)
        /// </summary>
        /// <param name="Sum1">Calculation Value1(계산값1)</param>
        /// <param name="Sum2">Calculation Value1(계간값2)</param>
        /// <returns>Result Value(결과값)</returns>
        public static double DoubleSubtraction(double Sum1, double Sum2)
        {
            decimal Sum = 0;
            try
            {
                Sum = Convert.ToDecimal(Sum1) - Convert.ToDecimal(Sum2);
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return Convert.ToDouble(Sum);
        }

        /// <summary>
        /// Double Type Subtraction (더블형 곱하기)
        /// </summary>
        /// <param name="Sum1">Calculation Value1(계산값1)</param>
        /// <param name="Sum2">Calculation Value1(계간값2)</param>
        /// <returns>Result Value(결과값)</returns>
        public static double DoubleMultiplication(double Sum1, double Sum2)
        {
            decimal Sum = 0;
            try
            {
                Sum = Convert.ToDecimal(Sum1) * Convert.ToDecimal(Sum2);
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return Convert.ToDouble(Sum);
        }

        /// <summary>
        /// Double Type Division (더블형 나누기)
        /// </summary>
        /// <param name="Sum1">Calculation Value1(계산값1)</param>
        /// <param name="Sum2">Calculation Value1(계간값2)</param>
        /// <returns>Result Value(결과값)</returns>
        public static double DoubleDivision(double Sum1, double Sum2)
        {
            decimal Sum = 0;
            try
            {
                Sum = Convert.ToDecimal(Sum1) / Convert.ToDecimal(Sum2);
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return Convert.ToDouble(Sum);
        }

        public static string IsNull(string sDestStr, string sSwitchStr)
        {
            try
            {
                if(sDestStr == null || sDestStr.Trim() == string.Empty)
                {
                    sDestStr = string.Empty;
                    sDestStr = sSwitchStr;
                }
            }
            catch
            {

            }

            return sDestStr;
        }

        /// <summary>
        /// 숫자인지 체크
        /// </summary>
        /// <param name="strValue"></param>
        /// <returns></returns>
        public static bool IsNumber(string strValue)
        {
            return IsNumber(strValue, false);
        }

        public static bool IsNumber(string sValue, bool bDotFlag)
        {
            int nDotCnt = 0;

            try
            {
                if (sValue == "") return false;

                if (sValue.Substring(0, 1) == "-")
                {
                    sValue = sValue.Substring(1, sValue.Length - 1);
                }

                for (int i = 0; i < sValue.Length; i++)
                {
                    if (sValue.Substring(i, 1).CompareTo("0") < 0 || sValue.Substring(i, 1).CompareTo("9") > 0)
                    {
                        if (bDotFlag == true && sValue.Substring(i, 1).CompareTo(".") == 0)
                        {
                            nDotCnt++;
                            if (nDotCnt > 1) return false;
                        }
                        else
                        {
                            return false;
                        }
                    }
                }
            }
            catch
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// 문자열 특정 갯수만큼 생성 처리
        /// </summary>
        /// <param name="sValue"></param>
        /// <returns></returns>
        public static string StringChar(string sValue, int nLen)
        {
            string sRetValue = "";
            try
            {
                for (int nIndex = 0; nIndex < nLen; nIndex++)
                {
                    sRetValue += sValue;
                }
            }
            catch (Exception ex)
            {
                return sRetValue;
            }
            return sRetValue;
        }
        /// <summary>
        /// 특정문자 특정 갯수만큼 생성 처리
        /// </summary>
        /// <author>Yoo</author>
        /// <param name="sValue"></param>
        /// <param name="sSource"></param>
        /// <param name="nLen"></param>
        /// <param name="sOrder"></param>
        /// <returns>sRetValue</returns>
        /// ex sValue "abc", sSource " ", nLen 10, nOrder "L" -> "       abc"
        /// ex sValue "abc", sSource " ", nLen 10, nOrder "L" -> "abc       "
        public static string StringfillChar(string sValue, string sSource, int nLen, string sOrder)
        {
            string sRetValue = sSource;
            int nGap = nLen - sValue.Length -1 ;
            try
            {
                if (nGap > 0)
                {
                    for (int nIndex = 0; nIndex < nGap; nIndex++)
                    {
                        sRetValue += sSource;
                    }
                    if (sOrder == "L")
                    {
                        sRetValue += sValue;
                    }
                    else
                    {
                        sValue += sRetValue;
                        sRetValue = sValue;
                    }
                }
                else
                {
                    if (sOrder == "L")
                    {
                        sRetValue = sSource + sValue;
                    }
                    else
                    {
                        sRetValue = sValue + sSource;
                    }
                    
                }
            }
            catch (Exception ex)
            {
                return sRetValue;
            }
            return sRetValue;
        }
        /// <summary>
        /// 특정 위치만 반환
        /// </summary>
        /// <author>Yoo</author>
        /// <param name="sSrc"></param>
        /// <param name="iPos"></param>
        /// <param name="iLength"></param>
        /// <returns>sRetValue</returns>        
        private string GetStringFromByteArray(byte[] sSrc, int iPos, int iLen)
        {
            string retStr = "";
            byte[] tmp = new byte[4096];

            Array.Clear(tmp, 0x0, tmp.Length);

            Array.Copy(sSrc, iPos, tmp, 0, iLen);

            retStr = System.Text.Encoding.Default.GetString(tmp).Trim('\0');

            return retStr;
        }
        /// <summary>
        /// 고객식별정보 마스킹 처리
        /// </summary>
        /// <param name="sPersonInfo"></param>
        /// <returns></returns>
        public static string MakePersonInfo(string sPersonInfo)
        {
            string sRet = sPersonInfo.TrimEnd();
            try
            {
                //if (sPersonInfo.TrimEnd().Length == 18) // 현금영수증 카드번호인 경우
                //    sRet = sPersonInfo.Substring(0, 4) + "-" + sPersonInfo.Substring(4, 4) + "-" + sPersonInfo.Substring(8, 2) + "**-**" + sPersonInfo.Substring(14, 4);
                //else if (sPersonInfo.TrimEnd().Length != 18 && sPersonInfo.TrimEnd().Length > 15) // 카드번호인 경우
                //    //sRet = sPersonInfo.Substring(0, 4) + "********" + sPersonInfo.Substring(12, 4);
                //    sRet = sPersonInfo.Substring(0, 4) + "********" + "****";
                //else if (sPersonInfo.TrimEnd().Length == 13)
                //    sRet = sPersonInfo.Substring(0, 5) + "*-***" + sPersonInfo.Substring(9, 4);
                //else if (sPersonInfo.TrimEnd().Length == 12)
                //    sRet = sPersonInfo.Substring(0, 4) + "****" + sPersonInfo.Substring(8, 4);
                //else if (sPersonInfo.TrimEnd().Length == 10)
                //    sRet = sPersonInfo.Substring(0, 2) + "*-**-*" + sPersonInfo.Substring(6, 4);
                //else if (sPersonInfo.TrimEnd().Length == 11)
                //    sRet = sPersonInfo.Substring(0, 3) + "-****-" + sPersonInfo.Substring(7, 4);
                
                //SPC 여전법 요청!

                //if (sPersonInfo.TrimEnd().Length == 11)
                //{
                //    sRet = sPersonInfo.Substring(0, 7) + "****";
                //}
                if (sPersonInfo.TrimEnd().Length > 6)
                {
                    sRet = CmUtil.MidH(sPersonInfo, 0, 6) + new string('*', sPersonInfo.TrimEnd().Length - 6);
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return sRet;
        }

        /// <summary>
        /// DateTime을 HHMMSS string으로 바꾼다
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static string TimeToStringHHMMSS(DateTime dt)
        {
            return dt.Hour.ToString("00") + dt.Minute.ToString("00") + dt.Second.ToString("00");
        }

        /// <summary>
        /// 대상문자열배열에 특정문자자 존재하는지 체크 한다.
        /// </summary>
        /// <param name="aDstStr"></param>
        /// <param name="sCompStr"></param>
        /// <returns></returns>
        public static bool ExistArrayString(string[] aDstStr, string sCompStr)
        {
            try
            {
                for (int i = 0; i < aDstStr.Length; i++)
                {
                    if (aDstStr[i] == sCompStr) return true;
                }
            }
            catch (Exception ex)
            {

            }
            return false;
        }

        /// <summary>
        /// 파일 사이즈 체크
        /// </summary>
        /// <param name="sCheckFile"></param>
        /// <returns></returns>
        public static long GetFileSize(string sCheckFile)
        {
            try
            {
                FileInfo FileInfo = new System.IO.FileInfo(sCheckFile);
                return FileInfo.Length;
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// 텍스트 파일의 최종 라인 읽기
        /// </summary>
        /// <param name="sFileName"></param>
        /// <returns></returns>
        public static string ReadFileLastLine(string sFileName)
        {
            string sReadLine = "";

            try
            {
                if (File.Exists(sFileName))
                {
                    FileStream fs = new FileStream(sFileName, FileMode.Open, FileAccess.Read);
                    StreamReader sr = new StreamReader(fs, Encoding.Default);

                    try
                    {
                        sr.BaseStream.Seek(0, SeekOrigin.Begin);

                        while (sr.Peek() > -1)
                        {
                            string sLine = sr.ReadLine();
                            if (sLine.Trim().Length == 0) continue;

                            sReadLine = sLine;
                        }
                    }
                    catch { }
                    finally
                    {
                        sr.Close();
                        fs.Close();
                    }
                }
            }
            catch { }

            return sReadLine;
        }

        /// <summary>
        /// 디렉토리 생성
        /// </summary>
        /// <param name="sPath"></param>
        /// <returns></returns>
        public static void CreateDirectory(string sPath)
        {
            try
            {
                if (Directory.Exists(sPath) == false) Directory.CreateDirectory(sPath);
            }
            catch { }
        }

        /// <summary>
        /// 파일복사 처리
        /// </summary>
        /// <param name="sSrcFileName"></param>
        /// <param name="sDstFileName"></param>
        /// <param name="bSrcDelete"></param>
        /// <returns></returns>
        public static bool FileCopy(string sSrcFileName, string sDstFileName, bool bSrcDelete)
        {
            try
            {
                if (File.Exists(sSrcFileName) == false) return false;

                // 파일복사 처리
                File.Copy(sSrcFileName, sDstFileName, true);        

                if ( bSrcDelete == true) File.Delete(sSrcFileName);

                return true;
            }
            catch { }

            return false;
        }

        /// <summary>
        /// 파일복사 처리
        /// </summary>
        /// <param name="sFileName">파일명</param>
        /// <param name="sSrcPath"></param>
        /// <param name="sDstPath"></param>
        /// <param name="sBackPath"></param>
        /// <returns></returns>
        public static bool FileCopy(string sFileName, string sSrcPath, string sDstPath, string sBackPath)
        {
            try
            {
                if (File.Exists(sSrcPath + sFileName) == false) return false;

                // 원 파일 백업
                if (sBackPath.Length > 0)
                {
                    CreateDirectory(sBackPath);
                    FileMove(sDstPath + sFileName, sBackPath + sFileName);          // 백업 처리
                }

                CreateDirectory(sDstPath);                                          // 대상폴더 생성
                File.Copy(sSrcPath + sFileName, sDstPath + sFileName, true);        // 파일복사 처리

                return true;
            }
            catch { }

            return false;
        }

        /// <summary>
        /// 디렉토리의 모든 파일복사 처리
        /// </summary>
        /// <param name="sSrcPath"></param>
        /// <param name="sDstPath"></param>
        /// <param name="sBackPath"></param>
        /// <returns></returns>
        public static bool DirectoryCopy(string sSrcPath, string sDstPath, string sBackPath)
        {
            try
            {
                DirectoryInfo di = new DirectoryInfo(sSrcPath);
                if (di.Exists)
                {
                    foreach (FileInfo fi in di.GetFiles())
                    {
                        FileCopy(fi.Name, sSrcPath, sDstPath, sBackPath);
                    }

                    foreach (DirectoryInfo fi in di.GetDirectories())
                    {
                        string sBckSubPath = string.IsNullOrEmpty(sBackPath) ? string.Empty : sBackPath + fi.Name + @"\";
                        DirectoryCopy(sSrcPath + fi.Name + @"\", sDstPath + fi.Name + @"\", sBckSubPath);
                        //DirectoryCopy(sSrcPath + fi.Name + @"\", sDstPath + fi.Name + @"\", sBackPath + fi.Name + @"\");
                    }
                }

                return true;
            }
            catch { }

            return false;
        }

        /// <summary>
        /// 파일 삭제
        /// </summary>
        /// <param name="sFileFullName"></param>
        /// <returns></returns>
        public static bool FileDelete(string sFileFullName)
        {
            try
            {
                if (File.Exists(sFileFullName) == false) return false;

                File.Delete(sFileFullName);

                return true;
            }
            catch { }

            return false;
        }

        /// <summary>
        /// 파일이동 처리
        /// </summary>
        /// <param name="sFileName">파일명</param>
        /// <param name="sSrcPath"></param>
        /// <param name="sDstPath"></param>
        /// <param name="sBackPath"></param>
        /// <returns></returns>
        public static bool FileMove(string sFileName, string sSrcPath, string sDstPath, string sBackPath)
        {
            return FileMove(sFileName, sSrcPath, sDstPath, sBackPath, sFileName);
        }
        public static bool FileMove(string sFileName, string sSrcPath, string sDstPath, string sBackPath, string sDstFileName)
        {
            try
            {
                if (File.Exists(sSrcPath + sFileName) == false) return false;

                // 원 파일 백업
                if (sBackPath.Length > 0)
                {
                    CreateDirectory(sBackPath);                                     // 백업폴더 생성
                    FileMove(sDstPath + sFileName, sBackPath + sFileName);          // 백업 처리
                }

                CreateDirectory(sDstPath);                                          // 폴더 생성
                FileMove(sSrcPath + sFileName, sDstPath + sDstFileName);            // 파일이동 처리

                return true;
            }
            catch { }

            return false;
        }
        public static void FileMove(string sSrcPath, string sDstPath)
        {
            for (int i = 0; i < 3; i++)
            {
                // 기존파일 삭제
                try
                {
                    File.Delete(sDstPath);
                }
                catch { }

                // 파일이동 처리
                try
                {
                    File.Move(sSrcPath, sDstPath);
                    break;
                }
                catch
                {
                    System.Threading.Thread.Sleep(100);
                }
            }
        }

        /// <summary>
        /// 디렉토리의 모든 파일이동 처리
        /// </summary>
        /// <param name="sSrcPath"></param>
        /// <param name="sDstPath"></param>
        /// <param name="sBackPath"></param>
        /// <returns></returns>
        public static bool DirectoryMove(string sSrcPath, string sDstPath, string sBackPath)
        {
            try
            {
                DirectoryInfo di = new DirectoryInfo(sSrcPath);
                if (di.Exists)
                {
                    foreach (FileInfo fi in di.GetFiles())
                    {
                        FileMove(fi.Name, sSrcPath, sDstPath, sBackPath);
                    }

                    foreach (DirectoryInfo fi in di.GetDirectories())
                    {
                        string sBckSubPath = string.IsNullOrEmpty(sBackPath) ? string.Empty : sBackPath + fi.Name + @"\";
                        DirectoryMove(sSrcPath + fi.Name + @"\", sDstPath + fi.Name + @"\", sBckSubPath);
                        //DirectoryMove(sSrcPath + fi.Name + @"\", sDstPath + fi.Name + @"\", sBackPath + fi.Name + @"\");
                    }
                }

                return true;
            }
            catch { }

            return false;
        }

        /// <summary>
        /// 디렉토리의 모든파일 삭제
        /// </summary>
        /// <param name="sSrcPath"></param>
        /// <param name="dtDelDate">삭제기준날짜</param>
        /// <param name="nDelSubDir">0:하위폴더삭제안함, 1:하위폴더삭제, 2:하위폴더삭제후폴더삭제 </param>
        /// <returns></returns>
        public static bool DeleteDirectoryInFile(string sSrcPath, DateTime dtDelDate, int nDelSubDir)
        {
            try
            {
                DirectoryInfo di = new DirectoryInfo(sSrcPath);
                if (di.Exists)
                {
                    if (nDelSubDir != 0)        // 하위폴더 삭제 여부
                    {
                        foreach (DirectoryInfo fi in di.GetDirectories())
                        {
                            DeleteDirectoryInFile(sSrcPath + fi.Name + @"\", dtDelDate, nDelSubDir);
                            try
                            {
                                if (nDelSubDir == 2) fi.Delete();
                            }
                            catch { }
                        }
                    }

                    foreach (FileInfo fi in di.GetFiles())
                    {
                        if (dtDelDate == null || fi.LastAccessTime < dtDelDate)
                        {
                            try
                            {
                                fi.Delete();
                            }
                            catch { }
                        }
                    }
                }

                return true;
            }
            catch { }

            return false;
        }

        /// <summary>
        /// 디렉토리의 모든파일 삭제
        /// </summary>
        /// <param name="sSrcPath"></param>
        /// <param name="nDelSubDir">0:하위폴더삭제안함, 1:하위폴더삭제, 2:하위폴더삭제후폴더삭제 </param>
        public static bool DeleteDirectoryInFile(string sSrcPath, int nDelSubDir)
        {
            try
            {
                DirectoryInfo di = new DirectoryInfo(sSrcPath);
                if (di.Exists)
                {
                    if (nDelSubDir != 0)        // 하위폴더 삭제 여부
                    {
                        foreach (DirectoryInfo fi in di.GetDirectories())
                        {
                            DeleteDirectoryInFile(sSrcPath + fi.Name + @"\", nDelSubDir);
                            try
                            {
                                if (nDelSubDir == 2) fi.Delete();
                            }
                            catch { }
                        }
                    }

                    foreach (FileInfo fi in di.GetFiles())
                    {
                        try
                        {
                            fi.Delete();
                        }
                        catch { }
                    }
                }

                return true;
            }
            catch { }

            return false;
        }

        /// <summary>
        /// Ping 테스트
        /// </summary>
        /// <param name="sIpAddress"></param>
        /// <returns></returns>
        public static bool PingTest(string sIpAddress)
        {
            try
            {
                if (sIpAddress.Trim().Replace(".", "").Length == 0) return false;

                System.Net.NetworkInformation.Ping pingSender = new System.Net.NetworkInformation.Ping();
                System.Net.NetworkInformation.PingOptions options = new System.Net.NetworkInformation.PingOptions();

                // Use the default Ttl value which is 128,but change the fragmentation behavior.
                options.DontFragment = true;

                // Create a buffer of 32 bytes of data to be transmitted.
                string data = "Create a buffer of 32 bytes of d";
                byte[] buffer = Encoding.ASCII.GetBytes(data);
                int timeout = 120;
                System.Net.NetworkInformation.PingReply reply = pingSender.Send(sIpAddress, timeout, buffer, options);

                if (reply.Status == System.Net.NetworkInformation.IPStatus.Success) return true;
                else return false;
            }
            catch { return false; }
        }

        /// <summary>
        /// String Null값 변환
        /// </summary>
        /// <param name="nAmt"></param>
        /// <returns></returns>
        public static string StringNullEmpty(string sValue)
        {
            try
            {
                if (string.IsNullOrEmpty(sValue)) return String.Empty;
                else return sValue;
            }
            catch (Exception ex)
            {

            }
            return "";
        }

        /// <summary>
        /// 화면표시용 카드번호 마스킹 처리
        /// </summary>
        /// <param name="sCardNo"></param>
        /// <returns></returns>
        public static string MakeDisplayCardNo(string sCardNo)
        {
            string sRet = sCardNo.TrimEnd();
            try
            {
                sRet = CmUtil.MidH(sCardNo, 0, 6) + "******" + "****";
                //if (sCardNo.TrimEnd().Length > 12)
                //{
                //    //sRet = sCardNo.Substring(0, 6) + "******" + sCardNo.Substring(12);
                //    sRet = sCardNo.Substring(0, 6) + "******" + "****";
                //}
                //else if (sCardNo.TrimEnd().Length > 6)
                //{
                //    sRet = sCardNo.Substring(0, 6).PadRight(sCardNo.Length, '*');
                //}
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return sRet;
        }

        /// <summary>
        /// DataRow 에서 값 획득
        /// </summary>
        /// <param name="drData"></param>
        /// <param name="sColumnName"></param>
        /// <returns></returns>
        public static string GetDataRowStr(DataRow drData, string sColumnName)
        {
            try
            {
                return drData[sColumnName].ToString();
            }
            catch
            {
                return "";
            }
        }

        /// <summary>
        /// DataRow 에서 값 획득
        /// </summary>
        /// <param name="drData"></param>
        /// <param name="sColumnName"></param>
        /// <returns></returns>
        public static long GetDataRowLong(DataRow drData, string sColumnName)
        {
            try
            {
                return (long)double.Parse(drData[sColumnName].ToString());
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// DataRow 에서 값 획득
        /// </summary>
        /// <param name="drData"></param>
        /// <param name="sColumnName"></param>
        /// <returns></returns>
        public static double GetDataRowDouble(DataRow drData, string sColumnName)
        {
            try
            {
                return double.Parse(drData[sColumnName].ToString());
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// DataRow 에서 값 획득
        /// </summary>
        /// <param name="drData"></param>
        /// <param name="sColumnName"></param>
        /// <returns></returns>
        public static int GetDataRowInt(DataRow drData, string sColumnName)
        {
            try
            {
                return (int)double.Parse(drData[sColumnName].ToString());
            }
            catch
            {
                return 0;
            }
        }
        /// <summary>
        /// DataRow 에서 값 획득
        /// </summary>
        /// <param name="drData"></param>
        /// <param name="sColumnName"></param>
        /// <returns></returns>
        public static float GetDataRowFloat(DataRow drData, string sColumnName)
        {
            try
            {
                return float.Parse(drData[sColumnName].ToString());
            }
            catch
            {
                return 0;
            }
        }

        /// <summary>
        /// 문자열에서 컬러 획득
        /// </summary>
        /// <param name="sColorStr"></param>
        /// <returns></returns>
        public static Color GetColorToString(string sColorStr)
        {
            try
            {
                if (sColorStr.Length >= 9) return Color.FromArgb(int.Parse(sColorStr.Substring(0, 3)), int.Parse(sColorStr.Substring(3, 3)), int.Parse(sColorStr.Substring(6, 3)));
            }
            catch { }
            return Color.White;
        }

        /// <summary>
        /// 사운드 파일 출력
        /// </summary>
        /// <param name="sFileName"></param>
        public static void PlaySound(string sFileName)
        {
            try
            {
                if (File.Exists(sFileName))
                {
                    SoundPlayer cPlayer = new SoundPlayer(sFileName);
                    cPlayer.Play();
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
        }

        /// <summary>
        /// Get System Date/Time Second
        /// </summary>
        /// <returns></returns>
        public static long GetSystemSecond()
        {
            long lSecond = 0;
            int[] arDays1 = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
            int[] arDays2 = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

            try
            {
                // 시스템 시간을 얻음 
                DateTime dtNow = DateTime.Now;

                // 초계산
                for (int nLoop = 1; nLoop < dtNow.Year; nLoop++)
                {
                    // 윤년
                    if ((nLoop % 4) == 0)
                    {
                        lSecond += (366 * 24 * 60 * 60);
                    }
                    // 평년
                    else
                    {
                        lSecond += (365 * 24 * 60 * 60);
                    }
                }

                // 윤년
                if ((dtNow.Year % 4) == 0)
                {
                    for (int nLoop = 1; nLoop < dtNow.Month; nLoop++)
                    {
                        lSecond += arDays2[nLoop - 1] * 24 * 60 * 60;
                    }
                }
                // 평년
                else
                {
                    for (int nLoop = 1; nLoop < dtNow.Month; nLoop++)
                    {
                        lSecond += arDays1[nLoop - 1] * 24 * 60 * 60;
                    }
                }

                // 일자 초계산
                lSecond += (dtNow.Day - 1) * 24 * 60 * 60;

                // 시간초계산
                lSecond += dtNow.Hour * 60 * 60;

                // 분초계산
                lSecond += dtNow.Minute * 60;

                // 초계산
                lSecond += dtNow.Second;
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }

            return lSecond;
        }

        /// <summary>
        /// Datetime to Second
        /// </summary>
        /// <param name="strDateTime"></param>
        /// <returns></returns>
        public static long GetYYYYMMDDHHMISSToSecond(string strDateTime)
        {
            int nYear, nMonth, nDay, nHour, nMinute, nSecond;
            long lSecond = 0;
            int[] arDays1 = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
            int[] arDays2 = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

            try
            {
                // 일자 / 시간 자리수 체크
                if (strDateTime.Length != 14)
                {
                    return -1;
                }

                // 숫자값이 아니면 에러
                if (IsNumber(strDateTime) == false)
                {
                    return -1;
                }

                // 년
                nYear = int.Parse(strDateTime.Substring(0, 4));

                // 월
                nMonth = int.Parse(strDateTime.Substring(4, 2));
                if (nMonth < 1 || nMonth > 12)
                {
                    return -1;
                }

                // 일
                nDay = int.Parse(strDateTime.Substring(6, 2));
                if (nDay < 1 || nDay > 31)
                {
                    return -1;
                }

                // 시
                nHour = int.Parse(strDateTime.Substring(8, 2));
                if (nHour < 0 || nHour > 24)
                {
                    return -1;
                }

                // 분
                nMinute = int.Parse(strDateTime.Substring(10, 2));
                if (nMinute < 0 || nMinute > 60)
                {
                    return -1;
                }

                // 초
                nSecond = int.Parse(strDateTime.Substring(12, 2));
                if (nSecond < 0 || nSecond > 60)
                {
                    return -1;
                }

                // 시스템 시간을 얻음 
                DateTime dtDateTime = new DateTime(nYear, nMonth, nDay, nHour, nMinute, nSecond);

                // 초계산
                for (int nLoop = 1; nLoop < dtDateTime.Year; nLoop++)
                {
                    // 윤년
                    if ((nLoop % 4) == 0)
                    {
                        lSecond += (366 * 24 * 60 * 60);
                    }
                    // 평년
                    else
                    {
                        lSecond += (365 * 24 * 60 * 60);
                    }
                }

                // 윤년
                if ((dtDateTime.Year % 4) == 0)
                {
                    for (int nLoop = 1; nLoop < dtDateTime.Month; nLoop++)
                    {
                        lSecond += arDays2[nLoop - 1] * 24 * 60 * 60;
                    }
                }
                // 평년
                else
                {
                    for (int nLoop = 1; nLoop < dtDateTime.Month; nLoop++)
                    {
                        lSecond += arDays1[nLoop - 1] * 24 * 60 * 60;
                    }
                }

                // 일자 초계산
                lSecond += (dtDateTime.Day - 1) * 24 * 60 * 60;

                // 시간초계산
                lSecond += dtDateTime.Hour * 60 * 60;

                // 분초계산
                lSecond += dtDateTime.Minute * 60;

                // 초계산
                lSecond += dtDateTime.Second;
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }

            return lSecond;
        }

        /// <summary>
        /// Second to Time
        /// </summary>
        /// <returns></returns>
        public static string ConvertSecondToHhMmDd(long lConvertSecond, bool bFormatFlag)
        {
            long lHour = 0, lMinute = 0, lSecond = 0;
            string strHhMmDd = "0:0:0";

            try
            {
                if (lConvertSecond < 0)
                {
                    return strHhMmDd;
                }

                // 시간계산
                lHour = lConvertSecond / (60 * 60);
                lConvertSecond = lConvertSecond - (lHour * (60 * 60));

                // 분계산
                lMinute = lConvertSecond / 60;
                lConvertSecond = lConvertSecond - (lMinute * 60);

                // 초계산
                lSecond = lConvertSecond;
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
            }

            if (bFormatFlag)
            {
                strHhMmDd = string.Format("{0}:{1:D2}:{2:D2}", lHour, lMinute, lSecond);
            }
            else
            {
                strHhMmDd = string.Format("{0}:{1}:{2}", lHour, lMinute, lSecond);
            }
            return strHhMmDd;
        }

        /// <summary>
        /// Second to Time
        /// </summary>
        /// <param name="lConvertSecond"></param>
        /// <returns></returns>
        public static string ConvertSecondToHhMmDd(long lConvertSecond)
        {
            return ConvertSecondToHhMmDd(lConvertSecond, false);
        }

        /// <summary>
        /// 메모리 변수 ZeroFill 초기화 함수 - 여신법대응
        /// </summary>
        /// <param name="sValue"></param>
        public static void ZeroFillClear(ref string sValue)
        {
            try
            {
                if (string.IsNullOrEmpty(sValue)) return;
                int nLen = sValue.Length;

                string sFill = "";
                sFill = new string('A', nLen); sValue = sFill;
                sFill = new string('0', nLen); sValue = sFill;
                sFill = new string('X', nLen); sValue = sFill;
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                                                        System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + 
                                                        System.Reflection.MethodBase.GetCurrentMethod().Name + "()", 
                                                        ex.Message);
            }
            finally
            {
                sValue = string.Empty;
            }
        }

        /// <summary>
        /// 메모리 변수 ZeroFill 초기화 함수 - 배열
        /// </summary>
        /// <param name="sVaules"></param>
        public static void ZeroFillClear(ref string[] sVaules)
        {
            try
            {
                if (sVaules == null) return;

                for (int iRow = 0; iRow < sVaules.Length; iRow++)
                {
                    ZeroFillClear(ref sVaules[iRow]);
                }
    
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
        }


        /// <summary>
        /// 마스터 출력크기 구분에 따른 출력 형태 획득
        /// </summary>
        /// <param name="sSizeDiv"></param>
        /// <returns></returns>
        public static string GetPrtMstToPrtHeadConst(string sSizeDiv, string sBoldYn)
        {
            string sPrtHead = PosConst.PRT_HDR.PRT_NOR;
            try
            {
                // 0:보통, 1:굵게, 2:가로확대, 3:세로확대, 4:전체확대
                switch (sSizeDiv)
                {
                    case PosConst.PRT_EXPAND_TYPE.BOLD:   // 굵게
                        sPrtHead = PosConst.PRT_HDR.PRT_BLD;
                        break;
                    case PosConst.PRT_EXPAND_TYPE.HOR:   // 가로확대
                        if (sBoldYn == "1")  // 0:보통, 1:BOLD
                            sPrtHead = PosConst.PRT_HDR.PRT_HRB;
                        else
                            sPrtHead = PosConst.PRT_HDR.PRT_HOR;;
                        break;
                    case PosConst.PRT_EXPAND_TYPE.VER:   // 세로확대
                        if (sBoldYn == "1")  // 0:보통, 1:BOLD
                            sPrtHead = PosConst.PRT_HDR.PRT_VRB;
                        else
                            sPrtHead = PosConst.PRT_HDR.PRT_VER;
                        break;
                    case PosConst.PRT_EXPAND_TYPE.BOTH:   // 전체확대
                        if (sBoldYn == "1")  // 0:보통, 1:BOLD
                            sPrtHead = PosConst.PRT_HDR.PRT_BGB;
                        else
                            sPrtHead = PosConst.PRT_HDR.PRT_BIG;
                        break;
                    default:   // 보통
                        if (sBoldYn == "1")  // 0:보통, 1:BOLD
                            sPrtHead = PosConst.PRT_HDR.PRT_BLD;
                        else
                            sPrtHead = PosConst.PRT_HDR.PRT_NOR;
                        break;
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return sPrtHead;
        }

        /// <summary>
        /// 이미지 파일 로딩
        /// </summary>
        /// <param name="sFileName"></param>
        /// <returns></returns>
        public static Image LoadImage( string sFileName)
        {
            try
            {
                if (sFileName == "" || File.Exists(sFileName) == false) return null;

                return Image.FromFile(sFileName);
            }
            catch { }
            return null;
        }

        /// <summary>
        /// 압축된 파일을 지정한 폴더에 푼다.
        /// </summary>
        /// <param name="sDirectoryNameToExtract">압축을 해방할 폴더(Full Path)</param>
        /// <param name="sZipFileName">압축된 파일명(Full Path)</param>
        public static bool UnZipFile(string sDirectoryNameToExtract, string sZipFileName)
        {
            bool bRet = false;

            try
            {
                // 압축을 풀 대상 파일이 존재하는지 확인
                if (!File.Exists(sZipFileName))
                    throw new Exception();

                // 압축을 풀 대상 폴더가 존재하지 않으면 생성
                if (!Directory.Exists(sDirectoryNameToExtract))
                    Directory.CreateDirectory(sDirectoryNameToExtract);

                // 압축을 풀 대상 폴더 내 디렉토리 생성
                using(ZipInputStream zis = new ZipInputStream(File.OpenRead(sZipFileName)))
                {
                    ZipEntry theEntry;
                    while((theEntry = zis.GetNextEntry()) != null)
                    {
                        if(theEntry.IsDirectory)
                        {
                            if (!Directory.Exists(sDirectoryNameToExtract + theEntry.Name))
                                Directory.CreateDirectory(sDirectoryNameToExtract + theEntry.Name);
                        }
                    }
                }

                // 압축을 풀 대상 폴더 내 파일 생성
                using(ZipInputStream zis = new ZipInputStream(File.OpenRead(sZipFileName)))
                {
                    ZipEntry theEntry;
                    while((theEntry = zis.GetNextEntry()) != null)
                    {
                        if(theEntry.IsFile)
                        {
                            string sFileName = Path.GetFileName(theEntry.Name);

                            if(sFileName != String.Empty)
                            {
                                // On some compression programs such as PangZip, etc., (빵집등 일부 압축 프로그램에서는) 
                                // theEntry.IsDirectory is not identified. (theEntry.IsDirectory 구분이 되지 않는다.)
                                // As the directory is recognized as like a file, the file format without extension is determined as a directory. (디렉토리도 파일처럼 인식하므로 확장자가 없는 파일형을 디렉토리로 판단한다.)
                                FileInfo fiTemp = new FileInfo(Path.Combine(sDirectoryNameToExtract, theEntry.Name));
                                if(fiTemp.Extension == "")
                                {
                                    if (!Directory.Exists(sDirectoryNameToExtract + theEntry.Name))
                                        Directory.CreateDirectory(sDirectoryNameToExtract + theEntry.Name);

                                    continue;
                                }
                                else
                                {
                                    if (!Directory.Exists(fiTemp.DirectoryName))
                                        Directory.CreateDirectory(fiTemp.DirectoryName);
                                }

                                using(FileStream streamWriter = File.Create(sDirectoryNameToExtract + theEntry.Name))
                                {
                                    int iReadLen = 2048;
                                    byte[] data = new byte[2048];
                                    while(true)
                                    {
                                        iReadLen = zis.Read(data, 0, data.Length);
                                        if(iReadLen > 0)
                                        {
                                            streamWriter.Write(data, 0, iReadLen);
                                        }
                                        else
                                        {
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                bRet = true;
            }
            catch (Exception ex)
            {
                bRet = false;
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return bRet;
        }

        /// <summary>
        /// Compress all files to the target folder . (including subdirectory) (대상폴더에 모든 파일을 압축한다. (하위 디렉토리 포함))
        /// </summary>
        /// <param name="pTargetFolder">Target Folder (대상폴더)</param> 
        /// <param name="pZipFileName">Zip Filename (압축파일명)</param>
        public static bool ZipFile(string pTargetFolder, string pZipFileName)
        {
            return ZipFile(pTargetFolder, pZipFileName, "");
        }
        public static bool ZipFile(string pTargetFolder, string pZipFileName, string pOnlyFileName)
        {
            bool bRet = false;

            // Designation of Target Folder for Compression (압축할 폴더 지정)
            DirectoryInfo diTarget = null;

            // For Files to be compressed (압축당할 파일용)
            FileStream fsTargetFile = null;

            // For Zip Files (압축파일용)
            FileStream fsZipFile = null;

            // Connect File Stream for Zip Files (압축파일용 파일스트림을 연결) 
            ICSharpCode.SharpZipLib.Zip.ZipOutputStream zips = null;

            try
            {
                if (File.Exists(pZipFileName))
                    File.Delete(pZipFileName);

                diTarget = new DirectoryInfo(pTargetFolder);

                // Target Directory Check (대상 디렉토리 체크)
                if (!diTarget.Exists)
                {
                    // In case of no compression object (압축할 대상이 없는경우)
                    throw new Exception();
                }

                fsZipFile = new FileStream(pZipFileName, FileMode.Create);

                zips = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(fsZipFile);

                // The Fastest Compression Level (압축율 Lenvel 최고 빠르게)
                zips.SetLevel(9);

                bRet = ZipDirectoryFile(diTarget, "", pZipFileName, pOnlyFileName, zips);
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
                bRet = false;
            }
            finally
            {
                // File Object Close Work (파일객체 Close 작업)
                if (zips != null)
                {
                    zips.Finish();
                    zips.Close();
                }

                if (fsZipFile != null)
                    fsZipFile.Close();
                if (fsTargetFile != null)
                    fsTargetFile.Close();
            }
            return bRet;
        }

        /// <summary>
        /// File Compression (Including Subdirectory (파일 압축 (서브 디렉토리 포함)) 
        /// </summary>
        /// <param name="pTarget"></param>
        /// <param name="pDescFolder"></param>
        /// <param name="pZipFileName"></param>
        /// <param name="pZip"></param>
        /// <returns></returns>
        private static bool ZipDirectoryFile(DirectoryInfo pTarget, string pDescFolder, string pZipFileName, string pOnlyFileName, ZipOutputStream pZip)
        {
            bool bRet = false;

            try
            {
                // For Files to be compressed (압축당할 파일용)
                FileStream fsTargetFile = null;

                byte[] buffer = new byte[2048];
                int size;

                string pZFileName = Path.GetFileName(pZipFileName);

                foreach (FileInfo fiTemp in pTarget.GetFiles())
                {
                    if (pZFileName == fiTemp.ToString()) continue;   // 자신은 압축에서 제외
                    
                    if (pOnlyFileName.Trim() != "")
                    {
                        if (pOnlyFileName != fiTemp.ToString()) continue;   // 지정 파일이 아닌경우 제외
                    }

                    ICSharpCode.SharpZipLib.Zip.ZipEntry theEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(pDescFolder + fiTemp.Name);

                    // Registration to Zip Entry (zip 엔트리에 등록)
                    pZip.PutNextEntry(theEntry);

                    // Get stream of file (파일의 스트림을 가져와서)
                    using (fsTargetFile = fiTemp.OpenRead())
                    {
                        // Read all and input into Zip stream as it is. (모두 읽어서 Zip 스트림에다가 그데로 넣어준다.)
                        while (true)
                        {
                            size = fsTargetFile.Read(buffer, 0, 2048);
                            if (size == 0)
                                break;

                            pZip.Write(buffer, 0, size);
                        }
                    }

                    // Entry Close (엔트리 닫기.)
                    pZip.CloseEntry();

                    if (pOnlyFileName.Trim() != "")
                    {
                        if (pOnlyFileName == fiTemp.ToString()) break;   // 지정 파일만 압축하고 Skip
                    }
                }
                bRet = true;

                foreach (DirectoryInfo diTemp in pTarget.GetDirectories())
                {
                    ICSharpCode.SharpZipLib.Zip.ZipEntry theEntry = new ICSharpCode.SharpZipLib.Zip.ZipEntry(pDescFolder + diTemp.Name + "\\");

                    // Registration on Zip Entry (zip 엔트리에 등록)
                    pZip.PutNextEntry(theEntry);

                    bRet = ZipDirectoryFile(diTemp, pDescFolder + diTemp.Name + "\\", pZipFileName, pOnlyFileName, pZip);

                    if (bRet != true) return bRet;
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
                bRet = false;
            }
            return bRet;
        }

        /// <summary>
        /// 텍스트 파일 읽기
        /// </summary>
        /// <param name="sFileName"></param>
        /// <returns></returns>
        public static string ReadTextFile(string sFileName)
        {
            return ReadTextFile(sFileName, System.Text.Encoding.Default);
        }
        public static string ReadTextFile(string sFileName, Encoding encoding)
        {
            string sReadData = "";
            try
            {
                if (File.Exists(sFileName) == false) return "";

                using (StreamReader sr = new StreamReader(sFileName, encoding))
                {
                    sr.BaseStream.Seek(0, SeekOrigin.Begin);
                    
                    sReadData = sr.ReadToEnd();
                    
                    sr.Close();
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return sReadData;
        }

        /// <summary>
        /// 텍스트 파일 쓰기
        /// </summary>
        /// <param name="sFileName"></param>
        /// <param name="sTextData"></param>
        /// <returns></returns>
        public static bool WriteTextFile(string sFileName, string sTextData)
        {
            return WriteTextFile(sFileName, sTextData, System.Text.Encoding.Default);
        }
        public static bool WriteTextFile(string sFileName, string sTextData, Encoding encoding)
        {
            try
            {
                //#20180322 휴게소pos매출연동 start,phj

                int iEndPos = 0;
                iEndPos = sFileName.LastIndexOf(@"\") + 1;
                // 해당 경로에 해당 하는 폴더가 없으면 만들어 줌 
                if (iEndPos > 0)
                {
                    string sRestAreaPosDir = string.Empty;
                    sRestAreaPosDir = sFileName.Substring(0, iEndPos);

                    if (Directory.Exists(sRestAreaPosDir) == false)
                    {
                        //DirectoryInfo di = new DirectoryInfo(sRestAreaPosDir);
                        //if (!di.Exists)
                        //{
                        //    di.Create();
                        //}
                        Directory.CreateDirectory(sRestAreaPosDir);
                    }

                }
                //#20180322 휴게소pos매출연동 end,phj

                using (StreamWriter sw = new StreamWriter(sFileName, false, encoding))
                {
                    sw.Write(sTextData);

                    sw.Close();

                    return true;
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return false;
        }

        /// <summary>
        /// Executes process and waits until it has finished
        /// <para>(프로세스를 실행하고 종료될 때 까지 대기)</para>
        /// </summary>
        /// <param name="sProcessName"></param>
        /// <param name="arguments"></param>
        public static void ExecuteWaitProcess(string sProcessName, string arguments)
        {
            ExecuteWaitProcess(sProcessName, arguments, System.Diagnostics.ProcessWindowStyle.Normal);
        }
        public static void ExecuteWaitProcess(string sProcessName, string arguments, System.Diagnostics.ProcessWindowStyle sWinSty, int millisecounds = 0)
        {
            try
            {
                System.Diagnostics.Process prc = new System.Diagnostics.Process();
                System.Diagnostics.ProcessStartInfo pcInfo = new System.Diagnostics.ProcessStartInfo();
                pcInfo.FileName = sProcessName;
                pcInfo.Arguments = arguments;
                pcInfo.WindowStyle = sWinSty;
                prc.StartInfo = pcInfo;
                prc.Start();
                if (millisecounds <= 0)
                    prc.WaitForExit();
                else
                    prc.WaitForExit(millisecounds);
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
        }

        /// <summary>
        /// Execute process
        /// (프로세스를 실행)
        /// </summary>
        /// <param name="sProcessName"></param>
        /// <param name="arguments"></param>
        public static void ExecuteProcess(string sProcessName, string arguments)
        {
            ExecuteProcess(sProcessName, arguments, System.Diagnostics.ProcessWindowStyle.Normal);
        }
        public static void ExecuteProcess(string sProcessName, string arguments, System.Diagnostics.ProcessWindowStyle sWinSty)
        {
            try
            {
                System.Diagnostics.Process prc = new System.Diagnostics.Process();
                System.Diagnostics.ProcessStartInfo pcInfo = new System.Diagnostics.ProcessStartInfo();
                pcInfo.FileName = sProcessName;
                pcInfo.Arguments = arguments;
                pcInfo.WindowStyle = sWinSty;
                prc.StartInfo = pcInfo;
                prc.Start();
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
        }

        /// <summary>
        /// 해피포인트 앱카드 체크
        /// </summary>
        /// <param name="sCardNo"></param>
        /// <returns></returns>
        public static bool CheckHappyMobileCard(string sCardNo)
        {
            try
            {
                if ( sCardNo.Trim().Length != 17) return true;

                if ("=" == sCardNo.Substring(16, 1)) return true;

                int nSum = 0;
                for (int i = 1 ; i <= 16 ; i++)
                {
                    // 카드번호각자리에 2, 1을 반복적으로 곱해서 그합을 10으로 나눈 몫과 나머지를 더한 합 을 구한다
                    int nNum = 0;
                    if (i % 2 == 1) 
                        nNum = CmUtil.IntParse(sCardNo.Substring(i - 1, 1)) * 2;
                    else
                        nNum = CmUtil.IntParse(sCardNo.Substring(i - 1, 1)) * 1;

                    nSum += (int)(nNum / 10) + (int)(nNum % 10);
                }
                
                // 구한값에 10으로 나눈 몫과 나머지를 뺀다
                int nCheck = 10 - ( nSum % 10);
                switch (nCheck)
                {
                    case 1:
                        if ("#" == sCardNo.Substring(16, 1)) return true;
                        break;
                    case 2:
                        if (")" == sCardNo.Substring(16, 1)) return true;
                        break;
                    case 3:
                        if ("&" == sCardNo.Substring(16, 1)) return true;
                        break;
                    case 4:
                        if ("$" == sCardNo.Substring(16, 1)) return true;
                        break;
                    case 5:
                        if ("@" == sCardNo.Substring(16, 1)) return true;
                        break;
                    case 6:
                        if ("%" == sCardNo.Substring(16, 1)) return true;
                        break;
                    case 7:
                        if ("!" == sCardNo.Substring(16, 1)) return true;
                        break;
                    case 8:
                        if ("^" == sCardNo.Substring(16, 1)) return true;
                        break;
                    case 9:
                        if ("~" == sCardNo.Substring(16, 1)) return true;
                        break;
                    case 0:
                    case 10:
                        if ("(" == sCardNo.Substring(16, 1)) return true;
                        break;
                }
                return false;
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
            return false;
        }

        /// <summary>
        /// Text To Speech
        /// </summary>
        /// <param name="sCountryCd"></param>
        /// <param name="sScript"></param>
        /// <param name="iVoulume"></param>
        public static void SpeakByTTSEngine(string sCountryCd, string sScript, int iVoulume)
        {
            try
            {
                string sVoiceName;
                if (sCountryCd == "en-US")
                {
                    sVoiceName = PosConst.TTS_VOICE_NAME.VOICE_en_US;
                }
                if (sCountryCd == "ja-JP")
                {
                    sVoiceName = PosConst.TTS_VOICE_NAME.VOICE_ja_JP;
                }
                if (sCountryCd == "zh-CN")
                {
                    sVoiceName = PosConst.TTS_VOICE_NAME.VOICE_zh_CN;
                }
                else
                {
                    sVoiceName = PosConst.TTS_VOICE_NAME.VOICE_ko_KR;
                }

                SpeakByTTS cTTS = new SpeakByTTS();
                cTTS.sVoiceName = sVoiceName;
                cTTS.sVoiceStr = sScript;
                cTTS.iVoulume = iVoulume;

                Thread t = new Thread(new ThreadStart(cTTS.DoWork));
                t.Start();
                
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR,
                                     System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,      // Project Name (프로젝트명)
                                     System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." +  // Class Name (Class Name (클래스명))
                                     System.Reflection.MethodBase.GetCurrentMethod().Name + "()",                // Function Name (Function Name (함수명))
                                     ex.Message);
            }
        }

        /// <summary>
        /// 인터넷 연결 체크
        /// </summary>
        /// <param name="dwFlags"></param>
        /// <returns></returns>
        public static int IsNetConnection()
        {

            int iRet = 1;
            int dwFlags = 0x02;

            try
            {
                // 0은 접속안됨, 1은 접속됨
                iRet = IsNetworkAlive(ref dwFlags);
            }
            catch (Exception ex)
            {

                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }

            return iRet;
        }


        /// <summary>
        /// 색상코드값으로 해당 색상 리턴
        /// </summary>
        /// <param name="sColorCode"></param>
        /// <returns></returns>
        public static Color GetRainbowColor(string sColorCode)
        {

            Color clrRetColor = Color.White;

            try
            {
                switch (sColorCode)
                {
                    case "0":
                    case "1":
                        clrRetColor = Color.Red;
                        break;
                    case "2":
                        clrRetColor = Color.Orange;
                        break;
                    case "3":
                        clrRetColor = Color.Yellow;
                        break;
                    case "4":
                        clrRetColor = Color.Green;
                        break;
                    case "5":
                        clrRetColor = Color.Blue;
                        break;
                    case "6":
                        clrRetColor = Color.Indigo;
                        break;
                    case "7":
                        clrRetColor = Color.Purple;
                        break;
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }

            return clrRetColor;
        }

        /// <summary>
        /// 화면 활성화시 초기 마우스 클릭 무시 처리
        /// </summary>
        /// <param name="frmForm"></param>
        public static void IgnoreMouseClick(Form frmForm)
        {
            try
            {
                Control cActive = frmForm.ActiveControl;        // 활성컨트롤

                Point nPoint = System.Windows.Forms.Cursor.Position;
                Cursor.Clip = new System.Drawing.Rectangle(1024, 0, 1, 1);

                frmForm.Update();
                System.Threading.Thread.Sleep(50);
                frmForm.Update();
                System.Threading.Thread.Sleep(50);
                frmForm.Update();
                System.Threading.Thread.Sleep(50);
                frmForm.Update();
                System.Threading.Thread.Sleep(50);
                frmForm.Update();
                System.Threading.Thread.Sleep(50);
                frmForm.Update();

                Cursor.Clip = Screen.PrimaryScreen.Bounds;
                Cursor.Position = nPoint;

                if (cActive != null && cActive != frmForm.ActiveControl) cActive.Focus();
            }
            catch { }
        }

        /// <summary>
        /// 지정한 일자의 로그파일을 압축파일로 백업 처리
        /// </summary>
        /// <param name="sSrcPath"></param>
        /// <param name="dtDelDate"></param>
        /// <returns></returns>
        public static bool BackUpLogToZipFile(string sSrcPath, DateTime dtDelDate)
        {
            try
            {
                DirectoryInfo di = new DirectoryInfo(sSrcPath);
                if (di.Exists == false) return false;

                string sLogBackPath = di.Name + dtDelDate.ToString("yyyyMMdd");
                if (File.Exists(sSrcPath + sLogBackPath + ".zip")) return true;

                try
                {
                    Directory.CreateDirectory(sSrcPath + sLogBackPath);
                }
                catch { }

                bool bFileExist = false;
                foreach (FileInfo fi in di.GetFiles())
                {
                    int Index = 0;
                    Index = fi.Name.IndexOf(dtDelDate.ToString("yyyyMMdd").Substring(2, 6));
                 //   if (fi.LastAccessTime.ToString("yyyyMMdd") == dtDelDate.ToString("yyyyMMdd"))
                    if(Index > 0)
                    {
                        if (fi.Extension.ToUpper() == "ZIP") continue;
                        try
                        {
                            fi.MoveTo(sSrcPath + sLogBackPath + @"\" + fi.Name);
                            bFileExist = true;
                        }
                        catch { }
                    }
                }

                if (bFileExist == true)
                {
                    if (ZipFile(sSrcPath + sLogBackPath, sSrcPath + sLogBackPath + ".zip") == true)
                    {
                        DeleteDirectoryInFile(sSrcPath + sLogBackPath, 2);
                        Directory.Delete(sSrcPath + sLogBackPath);
                    }
                }
                else
                {
                    Directory.Delete(sSrcPath + sLogBackPath);
                }
                return true;
            }
            catch { }

            return false;
        }

        /// <summary>
        /// 로그 저장 데이터 생성(카드번호 마스킹 처리)
        /// </summary>
        /// <param name="bIcUseYn"></param>
        /// <param name="sMaskData"></param>
        /// <param name="sWriteData"></param>
        /// <returns></returns>
        public static string MakeLogDataToMask(bool bIcUseYn, string sMaskData, string sLogData)
        {
            try
            {
                if (bIcUseYn == false)
                {
                    if (sMaskData.Length > 6)
                    {
                        string sReplaceData = sMaskData.Substring(0, 6).PadRight(sMaskData.Length, '*');

                        return sLogData.Replace(sMaskData, sReplaceData);
                    }
                }
            }
            catch { }

            return sLogData;
        }
    }

    /// <summary>
    /// TTS 처리 클레스
    /// </summary>
    class SpeakByTTS
    {
        /// <summary>
        /// 언어
        /// </summary>
        public string sVoiceName;
        /// <summary>
        /// 출력데이터
        /// </summary>
        public string sVoiceStr;
        /// <summary>
        /// 볼륨
        /// </summary>
        public int iVoulume;
        public void DoWork()
        {
            try
            {
                using (SpeechSynthesizer tts = new SpeechSynthesizer())
                {
                    tts.SelectVoice(sVoiceName);
                    tts.SetOutputToDefaultAudioDevice();
                    tts.Volume = iVoulume > 100 ? 100 : iVoulume;

                    tts.Speak(sVoiceStr);
                }
            }
            catch (Exception ex)
            {
                UserLog.WriteLogFile(UserCom.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
            }
        }

    }
}