1405 lines
50 KiB
C#
1405 lines
50 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.IO;
|
|
using System.Diagnostics;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
|
|
namespace NewPosInstaller
|
|
{
|
|
public class ComLib
|
|
{
|
|
/// <summary>
|
|
/// OK(정상)
|
|
/// </summary>
|
|
public const string RST_OK = "RSTOK|";
|
|
/// <summary>
|
|
/// ERROR(에러)
|
|
/// </summary>
|
|
public const string RST_ERR = "ERROR|";
|
|
/// <summary>
|
|
/// IGNORE(무시)
|
|
/// </summary>
|
|
public const string RST_IGNORE = "IGNOR|";
|
|
/// <summary>
|
|
/// RETRY(재시도)
|
|
/// </summary>
|
|
public const string RST_RETRY = "RETRY|";
|
|
|
|
/// <summary>
|
|
/// Normal
|
|
/// <para>(정상:1)</para>
|
|
/// </summary>
|
|
public const int OK = 1;
|
|
/// <summary>
|
|
/// Error0-Detail
|
|
/// <para>(에러0-상세)</para>
|
|
/// </summary>
|
|
public const int NG = 0;
|
|
/// <summary>
|
|
/// Error1-Detail
|
|
/// <para>(에러1-상세)</para>
|
|
/// </summary>
|
|
public const int NG1 = -1;
|
|
/// <summary>
|
|
/// Error2-Detail
|
|
/// <para>(에러2-상세)</para>
|
|
/// </summary>
|
|
public const int NG2 = -2;
|
|
/// <summary>
|
|
/// Error3-Detail
|
|
/// <para>(에러3-상세)</para>
|
|
/// </summary>
|
|
public const int NG3 = -3;
|
|
/// <summary>
|
|
/// Error4-Detail
|
|
/// <para>(에러4-상세)</para>
|
|
/// </summary>
|
|
public const int NG4 = -4;
|
|
|
|
/// <summary>
|
|
/// 각종 Debug 로그 FrameworkYYMMDD.log 파일에 기록
|
|
/// </summary>
|
|
public const string LOG_DEBUG = "Debug";
|
|
/// <summary>
|
|
/// Logging Phase "ERROR"
|
|
/// </summary>
|
|
public const string LOG_ERROR = "Error";
|
|
/// <summary>
|
|
/// Socket 로그 구분
|
|
/// </summary>
|
|
public const string LOG_SOCK = "Socket";
|
|
/// <summary>
|
|
/// Operation Flow 로그 구분
|
|
/// </summary>
|
|
public const string LOG_OP = "OpFlow";
|
|
/// <summary>
|
|
/// IO 관련 로그 구분
|
|
/// </summary>
|
|
public const string LOG_IOS = "IOS";
|
|
|
|
/// <summary>
|
|
/// LOG LEVEL
|
|
/// </summary>
|
|
public const int ERROR_LEVEL = 1;
|
|
public const int WARNING_LEVEL = 2;
|
|
public const int INFO_LEVEL = 3;
|
|
|
|
/// <summary>
|
|
/// 로그파일 최대 사이즈. 1MB 단위로 분할
|
|
/// </summary>
|
|
public const int LOG_MAX_SIZE = 1000000;
|
|
|
|
///// <summary>
|
|
///// Logging Phase "FATAL"
|
|
///// <para>(로깅 단계 "FATAL")</para>
|
|
///// </summary>
|
|
//public const string LOG_ERROR = "Fatal";
|
|
///// <summary>
|
|
///// 로깅 단계 "WARNNING"
|
|
///// <para>(Logging Phase "WARNNING")</para>
|
|
///// </summary>
|
|
//public const string LOG_WARN = "Warn";
|
|
|
|
///// <summary>
|
|
///// Logging Phase "INFORMATION"
|
|
///// <para>(로깅 단계 "INFORMATION")</para>
|
|
///// </summary>
|
|
//public const string LOG_INFO = "Info";
|
|
/// <summary>
|
|
/// Normal
|
|
/// <para>(정상)</para>
|
|
/// </summary>
|
|
public const string NORMAL = "Success";
|
|
/// <summary>
|
|
/// Error
|
|
/// <para>(에러)</para>
|
|
/// </summary>
|
|
public const string ERROR = "Error";
|
|
|
|
|
|
/// <summary>
|
|
/// HKEY_CURRENT_USERS Route of Registry
|
|
/// <para>(레지스트리의 HKEY_CURRENT_USERS 루트)</para>
|
|
/// </summary>
|
|
public const string HKCU = "HKEY_CURRENT_USERS\\";
|
|
|
|
/// <summary>
|
|
/// HKEY_LOCAL_MACHINE Route of Registry
|
|
/// <para>(레지스트리의 HKEY_LOCAL_MACHINE 루트)</para>
|
|
/// </summary>
|
|
public const string HKLM = "HKEY_LOCAL_MACHINE\\";
|
|
|
|
//public int COMM_MSGLEN_START = 2; // 메시지 길이 시작 위치
|
|
//public int COMM_MSGLEN = 5; // 메시지 길이
|
|
//public int COMM_HEAD_LEN = 42; // 6 --> 5
|
|
|
|
|
|
/// <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 = false)
|
|
{
|
|
try
|
|
{
|
|
if (File.Exists(sSrcFileName) == false) return false;
|
|
|
|
// 파일복사 처리
|
|
File.Copy(sSrcFileName, sDstFileName, true);
|
|
|
|
if (bSrcDelete == true)
|
|
{
|
|
//File.Delete(sSrcFileName);
|
|
for (var i = 0; i < 5; i++)
|
|
{
|
|
FileDelete(sSrcFileName);
|
|
if (File.Exists(sSrcFileName) == false) break;
|
|
Thread.Sleep(30);
|
|
}
|
|
}
|
|
|
|
return true; // File.Exists(sDstFileName);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ComLog.WriteLog(ComLog.Level.Exception
|
|
, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "."
|
|
+ System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
|
|
, ex.Message);
|
|
}
|
|
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 (Exception ex)
|
|
{
|
|
ComLog.WriteLog(ComLog.Level.Exception
|
|
, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "."
|
|
+ System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
|
|
, ex.Message);
|
|
}
|
|
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 + @"\";
|
|
CreateDirectory(sDstPath + fi.Name);
|
|
DirectoryCopy(sSrcPath + fi.Name + @"\", sDstPath + fi.Name + @"\", sBckSubPath);
|
|
//DirectoryCopy(sSrcPath + fi.Name + @"\", sDstPath + fi.Name + @"\", sBackPath + fi.Name + @"\");
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ComLog.WriteLog(ComLog.Level.Exception
|
|
, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "."
|
|
+ System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
|
|
, ex.Message);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static bool DirectoryMove(string sourcePath, string destPath)
|
|
{
|
|
try
|
|
{
|
|
DirectoryInfo di = new DirectoryInfo(sourcePath);
|
|
|
|
foreach (FileInfo fi in di.GetFiles())
|
|
{
|
|
fi.MoveTo(Path.Combine(destPath, fi.Name));
|
|
}
|
|
foreach (DirectoryInfo fi in di.GetDirectories())
|
|
{
|
|
fi.MoveTo(Path.Combine(destPath, fi.Name));
|
|
}
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ComLog.WriteLog(ComLog.Level.Exception
|
|
, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "."
|
|
+ System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
|
|
, ex.Message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 파일 삭제
|
|
/// </summary>
|
|
/// <param name="sFileFullName"></param>
|
|
/// <returns></returns>
|
|
public static bool FileDelete(string sFileFullName, bool isReadonly = false)
|
|
{
|
|
try
|
|
{
|
|
if (File.Exists(sFileFullName) == false) return false;
|
|
|
|
if (isReadonly)
|
|
{
|
|
FileInfo f = new FileInfo(sFileFullName);
|
|
f.IsReadOnly = false;
|
|
}
|
|
|
|
File.Delete(sFileFullName);
|
|
|
|
return true;
|
|
}
|
|
catch (UnauthorizedAccessException ex)
|
|
{
|
|
ComLog.WriteLog(ComLog.Level.Exception
|
|
, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "."
|
|
+ System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
|
|
, ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ComLog.WriteLog(ComLog.Level.Exception
|
|
, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "."
|
|
+ System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
|
|
, ex.Message);
|
|
}
|
|
|
|
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)
|
|
{
|
|
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 + sFileName); // 파일이동 처리
|
|
|
|
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;
|
|
}
|
|
|
|
public static bool ExistDirectory(string path)
|
|
{
|
|
return Directory.Exists(path);
|
|
}
|
|
|
|
public static int IntParse(string value)
|
|
{
|
|
try
|
|
{
|
|
return int.Parse(value);
|
|
}
|
|
catch{}
|
|
return 0;
|
|
}
|
|
|
|
public static double DoubleParse(string sValue)
|
|
{
|
|
try
|
|
{
|
|
if (sValue.Trim().Length > 0)
|
|
{
|
|
return double.Parse(sValue.Trim().Replace(",", ""));
|
|
}
|
|
}
|
|
catch { }
|
|
return 0;
|
|
}
|
|
|
|
public static long LongParse(string sValue)
|
|
{
|
|
try
|
|
{
|
|
if (sValue.Trim().Length > 0)
|
|
{
|
|
return (long)DoubleParse(sValue);
|
|
}
|
|
}
|
|
catch{}
|
|
return 0;
|
|
}
|
|
|
|
/// <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>
|
|
/// Return Trim processed (except 0) IP address
|
|
/// <para>(Trim 처리(0을 제외)한 IP주소를 반환한다.)</para>
|
|
/// </summary>
|
|
/// <param name="pStringIp">IP Address to be edited</param>
|
|
/// <para>(편집할 IP주소)</para>
|
|
/// <returns>Processed Result Value</returns>
|
|
/// <para>(처리결과값)</para>
|
|
/* --------------------------------------------------------------------------------- */
|
|
public static string TrimNetworkIpAddress(string pStringIp)
|
|
{
|
|
// Ip에서 왼쪽 0을 삭제하고, 000은 0으로 변환합니다.
|
|
//**************************************************************************************
|
|
if (pStringIp == null || pStringIp == "") return "0.0.0.0";
|
|
|
|
|
|
string strReturn = "";
|
|
string[] strSplitDot = pStringIp.Split('.');
|
|
for (int i = 0; i < strSplitDot.Length; i++)
|
|
{
|
|
strReturn += strSplitDot[i].TrimStart('0').PadLeft(1, '0') + ".";
|
|
}
|
|
return strReturn.Substring(0, strReturn.Length - 1);
|
|
}
|
|
/* --------------------------------------------------------------------------------- */
|
|
/// <summary>
|
|
/// Return IP address filled with 0s.
|
|
/// <para>(0을 채운 IP주소를 반환한다.)</para>
|
|
/// </summary>
|
|
/// <param name="pStringIp">IP Address to be edited</param>
|
|
/// <para>(편집할 IP주소)</para>
|
|
/// <returns>Processed Result Value</returns>
|
|
/// <para>(처리결과값)</para>
|
|
/* --------------------------------------------------------------------------------- */
|
|
public static string FillNetworkIpAddress(string pStringIp)
|
|
{
|
|
// Ip의 각부분에 3자리의 정수를 만들어 리턴합니다.
|
|
//**************************************************************************************
|
|
if (pStringIp == null || pStringIp == "") return "0.0.0.0";
|
|
|
|
string strReturn = "";
|
|
string[] strSplitDot = pStringIp.Split('.');
|
|
for (int i = 0; i < strSplitDot.Length; i++)
|
|
{
|
|
strReturn += strSplitDot[i].PadLeft(3, '0') + ".";
|
|
}
|
|
return strReturn.Substring(0, strReturn.Length - 1);
|
|
}
|
|
|
|
#region ##### UsUtil - String Edit Utility #####
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
/// <summary>
|
|
///
|
|
/// <para>(한글(2byte)을 포함한 문자열의 길이 반환)</para>
|
|
/// </summary>
|
|
/// <param name="sStr">대상 문자열</param>
|
|
/// <returns>길이</returns>
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
public static int LenH(string sStr)
|
|
{
|
|
return System.Text.Encoding.Default.GetByteCount(sStr);
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
/// <summary>
|
|
///
|
|
/// <para>(한글(2byte)을 포함한 문자열을 원하는 길이의 문자열로 생성 후 좌측정렬)</para>
|
|
/// </summary>
|
|
/// <param name="sStr">원본 문자열</param>
|
|
/// <param name="nLen">문자열 길이</param>
|
|
/// <returns>반환 문자열</returns>
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
public static string LPadH(string sStr, int nLen)
|
|
{
|
|
if (sStr == null) return "";
|
|
|
|
byte[] bt1 = System.Text.Encoding.Default.GetBytes(sStr);
|
|
|
|
int nL = bt1.Length;
|
|
//if (nL == 0) return ""; //->스트링이 empty여도 Pad해주기 위해 주석처리 20100902
|
|
|
|
if (nL > nLen)
|
|
{
|
|
return MidH(sStr, 0, nLen, 1);
|
|
//return System.Text.Encoding.Default.GetString(bt1, 0, nLen);
|
|
}
|
|
else
|
|
{
|
|
return "".PadLeft(nLen - nL) + sStr;
|
|
}
|
|
|
|
}
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
/// <summary>
|
|
/// <para>(한글(2byte)을 포함한 문자열을 원하는 길이의 문자열로 생성 후 우측정렬)</para>
|
|
/// </summary>
|
|
/// <param name="sStr">원본 문자열</param>
|
|
/// <param name="nLen"></param>
|
|
/// <returns>반환 문자열</returns>
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
public static string RPadH(string sStr, int nLen)
|
|
{
|
|
if (sStr == null) return "";
|
|
|
|
byte[] bt1 = System.Text.Encoding.Default.GetBytes(sStr);
|
|
|
|
int nL = bt1.Length;
|
|
//if (nL == 0) return ""; //->스트링이 empty여도 Pad해주기 위해 주석처리 20100902
|
|
|
|
|
|
if (nL > nLen)
|
|
{
|
|
|
|
return MidH(sStr, 0, nLen, 0);
|
|
//return System.Text.Encoding.Default.GetString(bt1, 0, nLen);
|
|
}
|
|
else
|
|
{
|
|
|
|
return sStr + "".PadLeft(nLen - nL);
|
|
}
|
|
|
|
}
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
/// <summary>
|
|
///
|
|
/// <para>(한글(2byte)을 포함한 문자열에서 좌측기준으로 원하는 길이만큼 문자열 반환)</para>
|
|
/// </summary>
|
|
/// <param name="sStr">원본 문자열</param>
|
|
/// <param name="nLength">길이</param>
|
|
/// <returns>String Data</returns>
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
public static string LeftH(string sStr, int nLength)
|
|
{
|
|
if (sStr == null) return "";
|
|
|
|
//byte[] bt1 = System.Text.Encoding.Default.GetBytes(sStr);
|
|
/*
|
|
int nL = bt1.Length;
|
|
if (nL == 0) return "";
|
|
|
|
//시작점보다 크고 원하는 길이보다 작으면 시작점부터 나머지를 반환
|
|
|
|
if (nL - nLen < 0)
|
|
{
|
|
nLen = nL;
|
|
}
|
|
return System.Text.Encoding.Default.GetString(bt1, 0, nLen);
|
|
*/
|
|
return MidH(sStr, 0, nLength, 0);
|
|
}
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
/// <summary>
|
|
/// <para>(한글(2byte)을 포함한 문자열에서 우측기준으로 원하는 길이만큼 문자열 반환)</para>
|
|
/// </summary>
|
|
/// <param name="sStr">원본 문자열</param>
|
|
/// <param name="nLength">길이</param>
|
|
/// <returns>반환 문자열</returns>
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
public static string RightH(string sStr, int nLength)
|
|
{
|
|
try
|
|
{
|
|
|
|
if (sStr == null) return "";
|
|
|
|
byte[] bt1 = System.Text.Encoding.Default.GetBytes(sStr);
|
|
|
|
int nL = bt1.Length;
|
|
if (nL == 0) return "";
|
|
|
|
//시작점보다 크고 원하는 길이보다 작으면 시작점부터 나머지를 반환
|
|
int nStart = nL - nLength;
|
|
/*
|
|
if (nL - nStart < nLength)
|
|
{
|
|
nLength = nL - nStart;
|
|
}
|
|
return System.Text.Encoding.Default.GetString(bt1, nStart, nLength);
|
|
*/
|
|
return MidH(sStr, nStart, nLength, 1);
|
|
}
|
|
catch
|
|
{
|
|
return sStr;
|
|
}
|
|
}
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
/// <summary>
|
|
///
|
|
/// <para>(한글(2byte)을 포함한 문자열에서 원하는 위치의 문자열 반환)</para>
|
|
/// </summary>
|
|
/// <param name="sStr">원본 문자열</param>
|
|
/// <param name="nStart">시작점</param>
|
|
/// <param name="nLength">길이</param>
|
|
/// <returns>반환 문자열</returns>
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
public static string MidH(string sStr, int nStart, int nLength)
|
|
{
|
|
/*
|
|
if (sStr == null) return "";
|
|
|
|
byte[] bt1 = System.Text.Encoding.Default.GetBytes(sStr);
|
|
|
|
int nL = bt1.Length;
|
|
if (nL == 0) return "";
|
|
|
|
if (nL <= nStart) return "";
|
|
|
|
//시작점보다 크고 원하는 길이보다 작으면 시작점부터 나머지를 반환
|
|
|
|
if (nL - nStart < nLength)
|
|
{
|
|
nLength = nL - nStart;
|
|
}
|
|
return System.Text.Encoding.Default.GetString(bt1, nStart, nLength);
|
|
*/
|
|
|
|
int nOrgLenth = nLength;
|
|
|
|
try
|
|
{
|
|
return MidH(sStr, nStart, nLength, 0);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ex.ToString();
|
|
}
|
|
|
|
return " ".PadRight(nOrgLenth);
|
|
|
|
}
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
/// <summary>
|
|
///
|
|
/// <para>(한글(2byte)을 포함한 문자열에서 원하는 위치의 문자열 반환)</para>
|
|
/// </summary>
|
|
/// <param name="sStr">원본 문자열</param>
|
|
/// <param name="nStart">시작점</param>
|
|
/// <param name="nLength">길이</param>
|
|
/// <param name="nArrType"></param>
|
|
/// <returns>반환 문자열</returns>
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
private static string MidH(string sStr, int nStart, int nLength, int nArrType)
|
|
{
|
|
/*
|
|
if (sStr == null) return "";
|
|
|
|
byte[] bt1 = System.Text.Encoding.Default.GetBytes(sStr);
|
|
|
|
int nL = bt1.Length;
|
|
if (nL == 0) return "";
|
|
|
|
if (nL <= nStart) return "";
|
|
|
|
//시작점보다 크고 원하는 길이보다 작으면 시작점부터 나머지를 반환
|
|
|
|
if (nL - nStart < nLength)
|
|
{
|
|
nLength = nL - nStart;
|
|
}
|
|
return System.Text.Encoding.Default.GetString(bt1, nStart, nLength);
|
|
*/
|
|
|
|
int nOrgLenth = nLength;
|
|
|
|
try
|
|
{
|
|
|
|
if (sStr != null && sStr != String.Empty)
|
|
{
|
|
//Encoding encoding = Encoding.GetEncoding("euc-kr");
|
|
byte[] abyBuf = System.Text.Encoding.Default.GetBytes(sStr); //encoding.GetBytes(sStr);
|
|
int nBuf = abyBuf.Length;
|
|
|
|
if (nStart < 0)
|
|
{
|
|
nStart = 0;
|
|
}
|
|
else if (nStart > nBuf)
|
|
{
|
|
nStart = nBuf;
|
|
}
|
|
|
|
if (nLength < 0)
|
|
{
|
|
nLength = 0;
|
|
}
|
|
else if (nLength > nBuf - nStart)
|
|
{
|
|
nLength = nBuf - nStart;
|
|
}
|
|
|
|
if (nStart < nBuf)
|
|
{
|
|
int nCopyStart = 0;
|
|
int nCopyLen = 0;
|
|
|
|
// 시작 위치를 결정한다.
|
|
if (nStart >= 1)
|
|
{
|
|
while (true)
|
|
{
|
|
if (abyBuf[nCopyStart] >= 0x80)
|
|
{
|
|
nCopyStart++;
|
|
}
|
|
|
|
nCopyStart++;
|
|
|
|
if (nCopyStart >= nStart)
|
|
{
|
|
if (nCopyStart > nStart)
|
|
{
|
|
nLength--;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 길이를 결정한다.
|
|
int nI = 0;
|
|
|
|
while (nI < nLength)
|
|
{
|
|
if (abyBuf[nCopyStart + nI] >= 0x80)
|
|
{
|
|
nI++;
|
|
}
|
|
|
|
nI++;
|
|
}
|
|
|
|
nCopyLen = (nI <= nLength) ? nI : nI - 2;
|
|
|
|
if (nCopyLen >= 1)
|
|
{
|
|
string sResult = "";
|
|
if (nOrgLenth - nCopyLen > 0) // nLength -->
|
|
{
|
|
if (nArrType == 0) // 우측 공백
|
|
sResult = System.Text.Encoding.Default.GetString(abyBuf, nCopyStart, nCopyLen) + " ".PadRight(nOrgLenth - nCopyLen);
|
|
else
|
|
sResult = " ".PadRight(nOrgLenth - nCopyLen) + System.Text.Encoding.Default.GetString(abyBuf, nCopyStart, nCopyLen);
|
|
}
|
|
else
|
|
sResult = System.Text.Encoding.Default.GetString(abyBuf, nCopyStart, nCopyLen);
|
|
return sResult;//encoding.GetString(abyBuf, nCopyStart, nCopyLen);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ex.ToString();
|
|
}
|
|
finally
|
|
{
|
|
//ZeroFillClear(ref sStr);
|
|
}
|
|
|
|
return " ".PadRight(nOrgLenth);
|
|
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
/// <summary>
|
|
/// Determine of string input of Control is number
|
|
/// <para>(Control의 문자열 입력값이 숫자인지 판별함. )</para>
|
|
/// </summary>
|
|
/// <param name="s">String to be checked if it is a number
|
|
/// <para>(숫자인지 체크할 문자열)</para></param>
|
|
/// <returns>If it is a number, return true
|
|
/// <para>(숫자일 경우 true 리턴)</para></returns>
|
|
/* ----------------------------------------------------------------------------------------- */
|
|
public static bool ChkIsNum(string s)
|
|
{
|
|
bool CheckVal = false;
|
|
|
|
for (int i = 0; i < s.Length; i++)
|
|
{
|
|
if (System.Char.IsNumber(s, i))
|
|
CheckVal = true;
|
|
else
|
|
{
|
|
if ((s.Substring(i, 1) == ".") || (s.Substring(i, 1) == ","))
|
|
CheckVal = true;
|
|
else
|
|
{
|
|
CheckVal = false;
|
|
break;
|
|
} //end of IF
|
|
} //end of IF
|
|
} //end of FOR
|
|
return CheckVal;
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <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 (Exception ex)
|
|
{
|
|
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public static string StrToDate(string sDateStr)
|
|
{
|
|
try
|
|
{
|
|
string temp = sDateStr.Replace("-", "").Replace("/", "");
|
|
if (temp.Length == 8)
|
|
{
|
|
return temp.Substring(0, 4) + "-" + temp.Substring(4, 2) + "-" + temp.Substring(6, 2);
|
|
}
|
|
else if (temp.Length == 6)
|
|
{
|
|
return temp.Substring(0, 4) + "-" + temp.Substring(4, 2);
|
|
}
|
|
else
|
|
{
|
|
return sDateStr;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
#region POS IRT 전문 송/수신
|
|
|
|
public bool ExecutePosIrt(string sMsgType, string sSvrIP, int nSvrPort, int nTimeout, Hashtable htSendData, ref Hashtable htRecvData)
|
|
{
|
|
try
|
|
{
|
|
string sCommHead = ItemColumn.MakeCommHeader(0, sMsgType); // 통신해더 생성
|
|
|
|
NetworkJSON netJson = new NetworkJSON();
|
|
int ret = netJson.IRTSendReceive(sSvrIP, nSvrPort, nTimeout, sCommHead, htSendData, ref htRecvData);
|
|
return ret == ComLib.OK ? true : false;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//WinManager.ExceptionMessage(System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
|
|
// System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
|
|
|
|
ComLog.WriteLog(ComLog.Level.Exception
|
|
, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "."
|
|
+ System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
|
|
, ex.Message);
|
|
return false;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
|
|
/// <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, System.Diagnostics.ProcessWindowStyle pwStyle = ProcessWindowStyle.Hidden, int milliseconds = 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 = pwStyle;
|
|
prc.StartInfo = pcInfo;
|
|
prc.Start();
|
|
|
|
if (milliseconds <= 0)
|
|
prc.WaitForExit();
|
|
else
|
|
prc.WaitForExit(milliseconds);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ComLog.WriteLogFile(ComLib.LOG_ERROR, System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.Name,
|
|
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "." + System.Reflection.MethodBase.GetCurrentMethod().Name + "()", ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 압축 (7za.exe를 이용한 zip 압축처리)
|
|
/// </summary>
|
|
/// <param name="zipFile"></param>
|
|
/// <param name="scrPath"></param>
|
|
/// <returns></returns>
|
|
public static bool ExcuteZip(string zipFile, string scrPath, System.Diagnostics.ProcessWindowStyle pwStyle = ProcessWindowStyle.Hidden)
|
|
{
|
|
try
|
|
{
|
|
string cmd = "7za.exe";
|
|
string arg = string.Format("{0} {1} {2}", "a", zipFile, scrPath);
|
|
ExecuteWaitProcess(cmd, arg, pwStyle);
|
|
System.Threading.Thread.Sleep(100);
|
|
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 압축해제 (7za.exe를 이용한 zip 압축해제처리)
|
|
/// </summary>
|
|
/// <param name="zipFile"></param>
|
|
/// <param name="trgPath"></param>
|
|
/// <returns></returns>
|
|
public static bool ExcuteUnzip(string zipFile, string trgPath, System.Diagnostics.ProcessWindowStyle pwStyle = ProcessWindowStyle.Hidden)
|
|
{
|
|
try
|
|
{
|
|
var cmd = "7za.exe";
|
|
|
|
if (File.Exists(cmd) == false) return false;
|
|
|
|
var arg = string.Format("{0} {1} {2}{3}", "x -aoa", zipFile, "-o", trgPath);
|
|
ExecuteWaitProcess(cmd, arg, pwStyle);
|
|
System.Threading.Thread.Sleep(100);
|
|
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public static bool ExcuteUnzip(string toolPath, string zipFile, string trgPath, ProcessWindowStyle pwStyle = ProcessWindowStyle.Hidden)
|
|
{
|
|
try
|
|
{
|
|
var cmd = toolPath + @"\7za.exe";
|
|
|
|
if (File.Exists(cmd) == false) return false;
|
|
|
|
var arg = string.Format("{0} {1} {2}{3}", "x -aoa", zipFile, "-o", trgPath);
|
|
ExecuteWaitProcess(cmd, arg, pwStyle);
|
|
System.Threading.Thread.Sleep(100);
|
|
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static string GetLocalIpAddress()
|
|
{
|
|
string retValue = string.Empty;
|
|
try
|
|
{
|
|
System.Net.IPHostEntry host = System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName());
|
|
string posip = string.Empty;
|
|
|
|
foreach (System.Net.IPAddress ip in host.AddressList)
|
|
{
|
|
if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
|
|
{
|
|
retValue = ip.ToString();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
retValue = string.Empty;
|
|
}
|
|
return retValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 설정 파일 읽기
|
|
/// </summary>
|
|
/// <param name="cCfgInfo"></param>
|
|
/// <param name="sGroup"></param>
|
|
/// <param name="sValueName"></param>
|
|
/// <returns></returns>
|
|
public static string GetConfigInfo(CmMessage cCfgInfo, string sGroup, string sValueName)
|
|
{
|
|
return GetConfigInfo(cCfgInfo, sGroup, sValueName, "");
|
|
}
|
|
public static string GetConfigInfo(CmMessage cCfgInfo, string sGroup, string sValueName, string sDefault)
|
|
{
|
|
try
|
|
{
|
|
string sValue = cCfgInfo.GetMessage(sGroup).GetMessageValue(sValueName);
|
|
if (sValue == null)
|
|
return sDefault;
|
|
else
|
|
return sValue;
|
|
}
|
|
catch { }
|
|
|
|
return sDefault;
|
|
}
|
|
|
|
/// <summary>
|
|
/// OS 버전 정보
|
|
/// (Environment.OSVersion 정보)
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static string GetOSVersionString(bool isFullName = false)
|
|
{
|
|
try
|
|
{
|
|
string retValue = string.Empty;
|
|
|
|
Version v = Environment.OSVersion.Version;
|
|
|
|
if (v.Major == 5 && v.Minor > 0)
|
|
{
|
|
retValue = "Windows XP ";
|
|
}
|
|
else if (v.Major == 6 && v.Minor == 0)
|
|
{
|
|
retValue = "Windows VISTA ";
|
|
}
|
|
else if (v.Major == 6 && v.Minor == 1)
|
|
{
|
|
retValue = "Windows 7 ";
|
|
}
|
|
else if (v.Major == 6 && v.Minor >= 2)
|
|
{
|
|
retValue = "Windows 8/10 ";
|
|
}
|
|
|
|
if (isFullName)
|
|
{
|
|
retValue += Environment.Is64BitOperatingSystem ? "(64Bit) " : "(32Bit) ";
|
|
retValue += Environment.OSVersion.ToString() + " ";
|
|
retValue += Environment.OSVersion.ServicePack + " ";
|
|
}
|
|
|
|
return retValue.Trim();
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// OS 버전 정보
|
|
/// (레지스트리 참조 관리자권한 일때 조회 가능)
|
|
/// HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static string GetOSProductName(bool isFullName = false)
|
|
{
|
|
try
|
|
{
|
|
string subKey = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion";
|
|
|
|
string product = Registry.GetValue(Microsoft.Win32.Registry.LocalMachine, subKey, "ProductName");
|
|
if (string.IsNullOrWhiteSpace(product)) return string.Empty;
|
|
|
|
string version = Registry.GetValue(Microsoft.Win32.Registry.LocalMachine, subKey, "CurrentVersion");
|
|
string service = Registry.GetValue(Microsoft.Win32.Registry.LocalMachine, subKey, "CSDVersion");
|
|
string process = Environment.Is64BitOperatingSystem ? "(64Bit)" : "(32Bit)";
|
|
|
|
if (isFullName)
|
|
return string.Format("{0} {1} {2} {3}", product, process, version, service).Trim();
|
|
else
|
|
return product.Trim();
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public static bool IsAdministrator()
|
|
{
|
|
System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent();
|
|
if (null != identity)
|
|
{
|
|
System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity);
|
|
return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static string GetCurrentPermission()
|
|
{
|
|
System.Security.Principal.WindowsIdentity identity = System.Security.Principal.WindowsIdentity.GetCurrent();
|
|
if (null != identity)
|
|
{
|
|
System.Security.Principal.WindowsPrincipal principal = new System.Security.Principal.WindowsPrincipal(identity);
|
|
if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator))
|
|
{
|
|
return "Administrator";
|
|
}
|
|
|
|
else if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.PowerUser))
|
|
{
|
|
return "PowerUser";
|
|
}
|
|
else if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.User))
|
|
{
|
|
return "User";
|
|
}
|
|
else if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Guest))
|
|
{
|
|
return "Guest";
|
|
}
|
|
|
|
else if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.AccountOperator))
|
|
{
|
|
return "AccountOperator";
|
|
}
|
|
else if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.BackupOperator))
|
|
{
|
|
return "BackupOperator";
|
|
}
|
|
|
|
else if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.PrintOperator))
|
|
{
|
|
return "PrintOperator";
|
|
}
|
|
else if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Replicator))
|
|
{
|
|
return "Replicator";
|
|
}
|
|
else if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Replicator))
|
|
{
|
|
return "Replicator";
|
|
}
|
|
else if (principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.SystemOperator))
|
|
{
|
|
return "SystemOperator";
|
|
}
|
|
|
|
}
|
|
return string.Empty;
|
|
}
|
|
|
|
public static string GetIpAddress(string hostName)
|
|
{
|
|
var retValue = hostName;
|
|
try
|
|
{
|
|
if (ComLib.IsNumber(hostName.Replace(".", "").Replace(":", "")) == false)
|
|
{
|
|
//System.Net.IPHostEntry hostEntry = System.Net.Dns.GetHostByName(hostName);
|
|
System.Net.IPHostEntry hostEntry = System.Net.Dns.GetHostEntry(hostName);
|
|
foreach (System.Net.IPAddress ip in hostEntry.AddressList)
|
|
{
|
|
retValue = ip.ToString();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ComLog.WriteLog(ComLog.Level.Exception
|
|
, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "."
|
|
+ System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
|
|
, ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
if (retValue != hostName)
|
|
ComLog.WriteLog(ComLog.Level.trace
|
|
, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name + "."
|
|
+ System.Reflection.MethodBase.GetCurrentMethod().Name + "()"
|
|
, string.Format("HostName:{0} => IPAddress:{1}", hostName, retValue));
|
|
}
|
|
return retValue;
|
|
}
|
|
}
|
|
}
|