spc-kiosk-pb/Library/Common/Utility.cs

2236 lines
80 KiB
C#
Raw Normal View History

2019-06-16 05:12:09 +00:00
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);
}
}
}
}