private RESULT PassOverSendRequest(P_TYPE p_destProcessType,
DbModule.SendRequestMasterInfo p_masterInfo,
DbModule.SendRequestDetailInfo p_detailInfo)
{
// FAX 발송 요청 건 대기상태로 전환 - DTL ////
if (DbModule.Instance.PassoverDetailSendReq(p_detailInfo.FAX_ID,
p_detailInfo.OUT_SEQ,
Config.PROCESS_TYPE,
Config.SYSTEM_PROCESS_ID,
p_destProcessType,
"Y") <= 0)
{
AppLog.Write(LOG_LEVEL.ERR, string.Format("Send Detail 테이블의 Pass Over가 실패하였습니다. FAX_ID: {0}, FAX_DTL_ID: {1}", p_detailInfo.FAX_ID, p_detailInfo.OUT_SEQ));
return(RESULT.F_DB_ERROR);
}
// FAX 발송 요청 건 대기상태로 전환 - MSTR ////
if (DbModule.Instance.PassoverMasterSendReq(p_masterInfo.OUT_FAX_ID,
Config.PROCESS_TYPE,
Config.SYSTEM_PROCESS_ID,
p_destProcessType) <= 0)
{
AppLog.Write(LOG_LEVEL.ERR, string.Format("Send Master 테이블의 Pass Over가 실패하였습니다. FAX_ID: {0}", p_masterInfo.OUT_FAX_ID));
return(RESULT.F_DB_ERROR);
}
return(RESULT.SUCCESS);
}
public List <LookupModel> getPatientByType(P_TYPE type)
{
try
{
OPDHistory entity = new OPDHistory();
return(entity.getPatientByType(type));
}
catch (Exception ex)
{
throw ex;
}
}
//public DashboardModel UserCollectionRecentActivity()
//{
// DashboardModel model = new DashboardModel();
// Guid? StatusId = Status.GetIdByName(OPD_STATUS.Waiting.ToString());
// using (var db = new HMSEntities())
// {
// #region User Collection
// var list = db.UserDetails.Where(u => u.IsActive == true);
// model.UsreCollection = new List<LookupModel>();
// foreach (var users in list)
// {
// Guid? prevoiusid = null;
// LookupModel md = new LookupModel();
// var hislist = db.OPDHistoryUpdates.AsEnumerable().Where(h => h.UpdatedBy == users.Id && h.UpdatedField == "PayingAmount" && h.CreatedOn.Value.Date == today);
// int records = hislist.Count();
// int index = 0;
// foreach (var item in hislist)
// {
// index++;
// if (prevoiusid == null)
// {
// prevoiusid = item.UpdatedBy;
// md.Rate = md.Rate == null ? Convert.ToDecimal(item.UpdatedValue) : md.Rate + Convert.ToDecimal(item.UpdatedValue);
// }
// else
// {
// md.Rate = md.Rate == null ? Convert.ToDecimal(item.UpdatedValue) : md.Rate + Convert.ToDecimal(item.UpdatedValue);
// }
// if (records == index)
// {
// md.Id = item.UpdatedBy.Value;
// md.Name = UserDetail.GetNameById(item.UpdatedBy.Value);
// model.UsreCollection.Add(md);
// md = new LookupModel();
// }
// }
// }
// #endregion
// #region Recent Activity
// model.RecentActivity = new List<OPDHistoryUpdateModel>();
// var activities = db.OPDHistoryUpdates.AsEnumerable().Where(h => h.CreatedOn.Value.Date == today).OrderByDescending(t => t.CreatedOn);
// foreach (var item in activities)
// {
// OPDHistoryUpdateModel lookup = new OPDHistoryUpdateModel();
// lookup.Id = item.Id;
// lookup.CasePaper = GetById(item.OPDHistoryId).CasePaperNumber;
// lookup.UpdatedName = UserDetail.GetNameById(item.UpdatedBy.Value);
// lookup.UpdatedField = item.UpdatedField;
// switch (item.UpdatedField)
// {
// case "XRAYAmount":
// case "ECGAmount":
// case "PayingAmount":
// case "ThirdPartyLabAmoumt":
// case "LabTestingAmount":
// lookup.PreviousValue = item.PreviousValue != null ? Convert.ToString(item.PreviousValue) : "";
// lookup.UpdatedValue = item.UpdatedValue != null ? Convert.ToString(item.UpdatedValue) : "";
// break;
// case "IsCharity":
// case "IsXRAY":
// case "IsECG":
// case "IsLabCharity":
// lookup.PreviousValue = item.PreviousValue != null ? Convert.ToBoolean(item.PreviousValue) ? "Yes" : "No" : "";
// lookup.UpdatedValue = item.UpdatedValue != null ? Convert.ToBoolean(item.UpdatedValue) ? "Yes" : "No" : "";
// break;
// case "StatusId":
// lookup.PreviousValue = item.PreviousValue != null ? Status.GetNameById(new Guid(item.PreviousValue)) : "";
// lookup.UpdatedValue = item.UpdatedValue != null ? Status.GetNameById(new Guid(item.UpdatedValue)) : "";
// break;
// default:
// break;
// }
// model.RecentActivity.Add(lookup);
// }
// #endregion
// }
// return model;
//}
public List <LookupModel> getPatientByType(P_TYPE type)
{
List <LookupModel> list = new List <LookupModel>();
DateTime today = DateTime.Today;
bool isXRAY = false;
Expression <Func <OPDHistory, bool> > predicate = null;
switch (type)
{
case P_TYPE.ECG:
predicate = t => t.IsECG == true && DbFunctions.TruncateTime(t.InTime.Value) == today;
break;
case P_TYPE.XRAY:
predicate = t => t.IsXRAY == true && DbFunctions.TruncateTime(t.InTime.Value) == today;
isXRAY = true;
break;
case P_TYPE.CHARITY:
predicate = t => t.IsCharity == true && DbFunctions.TruncateTime(t.InTime.Value) == today;
break;
case P_TYPE.LABCHARITY:
predicate = t => t.IsLabCharity == true && DbFunctions.TruncateTime(t.InTime.Value) == today;
break;
default:
break;
}
using (var db = new HMSEntities())
{
var val = db.OPDHistories.Where(predicate);
foreach (var item in val)
{
LookupModel md = new LookupModel();
md.Name = item.PatientDetail != null ? item.PatientDetail.FullName : "";
md.Id = item.PatientId;
md.Description = item.PatientDetail.CasePaperNumber;
md.PerentName = isXRAY == true?Convert.ToString(item.NumberofXRAY) : "";
list.Add(md);
}
}
return(list);
}
private void SetReqType(List <POP3_BoundaryInfo> biList,
ref DbModule.SendRequestMasterInfo p_reqInfo_mstr,
ref DbModule.SendRequestDetailInfo p_reqInfo_dtl,
ref P_TYPE destProcessType)
{
if (biList.Count == 1)
{
p_reqInfo_mstr.REQ_TYPE = "02";
destProcessType = P_TYPE.DCV;
}
else if (biList.Count > 1)
{
p_reqInfo_mstr.REQ_TYPE = "12";
destProcessType = P_TYPE.DCV;
}
}
public bool FinishIBSendDtl(long p_systemNo, P_TYPE p_processType, string strSystemProcessID, string strBroadcastYN, SEND_REQUEST_DTL_PSC p_sendRequestInfo, RESULT p_result = RESULT.SUCCESS)
{
string strProcedureName = "PKG_PRC_FOD.USP_FINISH_SEND_DTL";
lock (m_connection)
{
if (!ReOpen())
{
return(false);
}
try
{
using (OracleCommand command = new OracleCommand())
{
command.Connection = m_connection;
command.CommandText = strProcedureName;
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("P_FAX_ID", p_sendRequestInfo.faxId);
command.Parameters.AddWithValue("P_FAX_DTL_ID", p_sendRequestInfo.faxDtlId);
command.Parameters.AddWithValue("P_PROCESS_TYPE", p_processType.ToString());
command.Parameters.AddWithValue("P_SYSTEM_ID", p_systemNo);
command.Parameters.AddWithValue("P_SYSTEM_PROCESS_ID", strSystemProcessID);
command.Parameters.AddWithValue("P_FOD_CHANNEL", 99999);
command.Parameters.AddWithValue("P_RESULT_CODE_3", string.Format("{0:D03}", (int)p_result));
command.Parameters.AddWithValue("P_BROADCAST_YN", strBroadcastYN);
command.Parameters.AddWithValue("P_LAST_PAGE_SENT", p_sendRequestInfo.strLastPagesSent);
int cnt = command.ExecuteNonQuery();
if (cnt < 1)
{
return(false);
}
}
}
catch (Exception ex)
{
ExceptionMsg(ex, "PROCEDURE : " + strProcedureName);
return(false);
}
Close();
return(true);
}
}
public RESULT FailSendReqs(decimal p_faxId, decimal p_faxDtlId, P_TYPE p_processType, string p_processId, RESULT p_result)
{
//// DTL건 업데이트 ////
int ret = FailSendReqDetail(p_faxId, p_faxDtlId, p_processType, p_processId, p_result);
if (ret < 0)
{
return(RESULT.F_DB_UPDATE_ERROR);
}
//// MSTR건 업데이트 ////
ret = DbModule.Instance.FailSendReqMaster(p_faxId, p_processType, p_processId);
if (ret < 0)
{
return(RESULT.F_DB_UPDATE_ERROR);
}
return(RESULT.SUCCESS);
}
public RESULT PSI_InsertProcessLog(P_TYPE p_processType, string p_strSystemProcessId, decimal p_FAX_ID, RESULT p_REASON, string p_INFO_EXTRA)
{
RESULT ret = RESULT.EMPTY;
string strProcedureName = "PKG_PRC_PSI.USP_INSERT_PROCESS_LOG";
lock (m_connection)
{
if (!ReOpen())
{
return(RESULT.F_DB_OPENERROR);
}
try
{
using (OracleCommand command = new OracleCommand())
{
command.Connection = m_connection;
command.CommandText = strProcedureName;
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("P_FAX_ID", p_FAX_ID);
command.Parameters.AddWithValue("P_PROCESS_TYPE", p_processType.ToString());
command.Parameters.AddWithValue("P_FETCH_PROCESS", p_strSystemProcessId);
command.Parameters.AddWithValue("P_REASON", ((int)p_REASON).ToString().PadLeft(3, '0'));
command.Parameters.AddWithValue("P_INFO_EXTRA", p_INFO_EXTRA);
command.ExecuteNonQuery();
ret = RESULT.SUCCESS;
}
}
catch (Exception ex)
{
ExceptionMsg(ex, "PROCEDURE : " + strProcedureName);
ret = RESULT.F_SYSTEM_ERROR;
}
}
return(ret);
}
private RESULT PassOverSendRequest(P_TYPE p_destProcessType,
DbModule.SendRequestMasterInfo p_masterInfo,
DbModule.SendRequestDetailInfo p_detailInfo)
{
// FAX 발송 요청 건 대기상태로 전환 - DTL ////
if (DbModule.Instance.PassoverDetailSendReq(p_detailInfo.FAX_ID,
p_detailInfo.OUT_SEQ,
Config.PROCESS_TYPE,
Config.SYSTEM_PROCESS_ID,
p_destProcessType,
"Y") <= 0)
{
return(RESULT.F_DB_ERROR);
}
// FAX 발송 요청 건 대기상태로 전환 - MSTR ////
if (DbModule.Instance.PassoverMasterSendReq(p_masterInfo.OUT_FAX_ID,
Config.PROCESS_TYPE,
Config.SYSTEM_PROCESS_ID, p_destProcessType) <= 0)
{
return(RESULT.F_DB_ERROR);
}
return(RESULT.SUCCESS);
}
private void getPatientList(P_TYPE type)
{
try
{
List <LookupModel> list = service.getPatientByType(type);
if (type == P_TYPE.XRAY)
{
this.dgvList.Columns["XRAYCount"].Visible = true;
}
else
{
this.dgvList.Columns["XRAYCount"].Visible = false;
}
dgvList.AutoGenerateColumns = false;
dgvList.DataSource = list;
dgvList.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCells);
dgvList.Refresh();
dgvList.ClearSelection();
}
catch (Exception ex)
{
Utility.ErrorLog.Logging("Main Dashboard", ex.Message.ToString(), ex.StackTrace.ToString());
}
}
public patientDialog(P_TYPE type)
{
InitializeComponent();
getPatientList(type);
}
/// <summary>
/// Name : PollingLoop_
/// Parameters : Empty
/// Content : 폴링 루프
/// Return : Empty
/// Writer : 장동훈
/// Date : 2012.09.03
/// </summary>
private void PollingLoop_()
{
POP3_Client mail = new POP3_Client();
DbModule.SendRequestMasterInfo reqInfo_mstr = null;
DbModule.SendRequestDetailInfo reqInfo_dtl = null;
DbModule.SEND_REQ_SITE reqInfo_site = null;
List <DbModule.SendRequestDocInfo> reqInfo_doc_List = null;
P_TYPE destProcessType = P_TYPE.PSC;
int retryConnectCount = 0; // POP3 접속 실패시 3회 재시도
int retryLoginCount = 0; // POP3 로그인 실패시 3회 재시도
/// 마지막 실행시간 (Sleep 실행의 기준시간)
/// 첫 Sleep 실행시 바로 실행 되도록 시간 수정
DateTime lastExecuteTime = DateTime.Now.AddMilliseconds(Config.EMAIL_POLLING_TIME * -1);
try
{
while (!BtfaxThread.Stop)
{
if (DateTime.Now.Subtract(lastExecuteTime).TotalMilliseconds < Config.EMAIL_POLLING_TIME)
{
Thread.Sleep(1000);
continue;
}
lastExecuteTime = DateTime.Now;
try
{
if (mail.IsConnected == false &&
!mail.Connect(Config.EMAIL_POP_SERVER, Config.EMAIL_POP3_SERVER_PORT))
{
if (retryConnectCount++ < 3)
{
AppLog.Write(LOG_LEVEL.ERR, string.Format("IP: {0}, PORT: {1} 로 접속중 오류가 발생하였습니다. ({2} 회 접속 시도)", Config.EMAIL_POP_SERVER, Config.EMAIL_POP3_SERVER_PORT, retryConnectCount));
/// 0.5 초 대기
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
}
mail = new POP3_Client();
continue;
}
else
{
AppLog.Write(LOG_LEVEL.ERR, "해당 서버로 접속 연결이 되지 않습니다.");
throw new Exception("접속 에러");
}
}
if (mail.IsLogin == false &&
!mail.Login(Config.EMAIL_ID, Config.EMAIL_PW))
{
if (retryLoginCount++ < 3)
{
AppLog.Write(LOG_LEVEL.ERR, string.Format("ID: {0}, PASSWORD: {1} 로 로그인중 오류가 발생하였습니다. ({2} 회 로그인 시도)", Config.EMAIL_ID, string.Empty.PadRight(Config.EMAIL_PW.Length, '*'), retryLoginCount));
/// 0.5 초 대기
for (int i = 0; i < 5; i++)
{
Thread.Sleep(100);
}
continue;
}
else
{
AppLog.Write(LOG_LEVEL.ERR, "해당 서버로 로그인이 되지 않습니다.");
throw new Exception("로그인 에러");
}
}
/// 초기화
retryConnectCount = 0;
retryLoginCount = 0;
int messageCount = mail.GetMailCount();
for (int i = 1; i <= messageCount; i++)
{
POP3_Parsing parseMail = mail.GetMessage(i);
if (parseMail.IsParseSuccess == false)
{
continue;
}
if (ParseEmailDocument(parseMail,
ref reqInfo_mstr,
ref reqInfo_dtl,
ref reqInfo_site,
ref reqInfo_doc_List,
ref destProcessType) != RESULT.SUCCESS)
{
continue;
}
/// Master, Detail DB Insert
if (InsertToDb(reqInfo_mstr, reqInfo_dtl, reqInfo_site) != RESULT.SUCCESS)
{
continue;
}
/// Doc DB Insert
if (InsertToDbDoc(reqInfo_mstr.OUT_FAX_ID, reqInfo_doc_List) != RESULT.SUCCESS)
{
continue;
}
// FAXBOX Insert - 20130124
if (InsertToDbFaxbox(reqInfo_mstr) != RESULT.SUCCESS)
{
continue;
}
/// Pass Over
if (PassOverSendRequest(destProcessType, reqInfo_mstr, reqInfo_dtl) != RESULT.SUCCESS)
{
continue;
}
break;
}
/// 메일함 Update
mail.Disconnect();
lastExecuteTime = DateTime.Now;
}
catch (Exception ex)
{
lastExecuteTime = DateTime.Now;
AppLog.ExceptionLog(ex, string.Format("{0} 쓰레드에서 다음과 같은 오류가 발생하였습니다.-1", m_ThreadName));
if (mail.IsConnected == true)
{
mail.ResetDeleteMessage();
}
AppLog.ExceptionLog(ex, string.Format("{0} 쓰레드에서 다음과 같은 오류가 발생하였습니다.-2", m_ThreadName));
//throw ex;
}
} // while
}
catch (Exception ex)
{
AppLog.ExceptionLog(ex, string.Format("{0} 쓰레드에서 다음과 같은 오류가 발생하였습니다. 쓰레드를 종료합니다.-1", m_ThreadName));
if (mail.IsConnected == true)
{
mail.ResetDeleteMessage();
}
AppLog.ExceptionLog(ex, string.Format("{0} 쓰레드에서 다음과 같은 오류가 발생하였습니다. 쓰레드를 종료합니다.-2", m_ThreadName));
throw ex;
}
}
protected override void ThreadEntry()
{
while (!BtfaxThread.Stop)
{
//// 작업 요청 건 큐 폴링 ////
ClearTmkSendReqInfo();
m_tmkReqInfo = OutFaxQueue.Instance.Dequeue();
if (m_tmkReqInfo == null || m_tmkReqInfo.faxId < 0)
{
System.Threading.Thread.Sleep(QUEUE_POLLING_SLEEP);
continue;
}
//// 다음 프로세스 유형 SET ////
P_TYPE nextProcessType = P_TYPE.NONE;
switch (Convert.ToInt32(m_tmkReqInfo.strReqType))
{
case (int)REQ_TYPE.TMK: nextProcessType = P_TYPE.PSC; break;
case (int)REQ_TYPE.TMK_TPC: nextProcessType = P_TYPE.TPC; break;
case (int)REQ_TYPE.TMK_DCV_TPC: nextProcessType = P_TYPE.DCV; break;
}
LogMessage(string.Format("[FAX_ID:{0}] 팩스요청건점유", m_tmkReqInfo.faxId), RESULT.SUCCESS);
//// TIF 생성정보 GET ////
RESULT result = DbModule.Instance.GetTiffMakingInfo(ref m_tmkReqInfo);
if (result != RESULT.SUCCESS)
{
LogError(string.Format("[FAX_ID:{0}] TIF생성 정보를 얻어오지 못하였습니다", m_tmkReqInfo.faxId), result);
//// MSTR 실패처리 ////
if (DbModule.Instance.FailSendReqMaster(m_tmkReqInfo.faxId, P_TYPE.TMK, Config.SYSTEM_PROCESS_ID) < 0)
{
LogError(string.Format("[FAX_ID:{0}] 작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId));
}
//// DTL 전체실패처리 ////
if (DbModule.Instance.FailSendReqDetail(m_tmkReqInfo.faxId, -1, P_TYPE.TMK, Config.SYSTEM_PROCESS_ID, result) < 0)
{
LogError(string.Format("[FAX_ID:{0}] 작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId));
}
continue;
}
bool docInfoExistInDb = true;
DbModule.DOC_INFO_ALL_TMK docInfoAll = m_tmkReqInfo.m_tmkDocInfoAll;
if (docInfoAll == null)
{
docInfoExistInDb = false;
m_tmkDocInfoAll.Clear();
docInfoAll = m_tmkDocInfoAll;
docInfoAll.strProcessingMode = ((int)DOC_PROCESSING_MODE.TMK).ToString();
docInfoAll.strTiffExtractPages = "all";
}
docInfoAll.strDocExt = "TIF";
docInfoAll.strDocPath = ".";
string strSrcFaxFormFullName = string.Format("{0}\\{1}{2}\\{3}", Config.STG_HOME_PATH
, Config.FAXFORM_PATH
, m_tmkReqInfo.m_strFaxFormPath
, m_tmkReqInfo.m_strFaxFormFileName);
string strLocalFaxFormFullName = string.Format("{0}\\{1}.fax", Config.TIFF_MAKING_PATH
, m_tmkReqInfo.faxId);
//// 팩스폼 다운로드 ////
result = DownloadFaxForm(strSrcFaxFormFullName, strLocalFaxFormFullName);
if (result != RESULT.SUCCESS)
{
//// MSTR 실패처리 ////
if (DbModule.Instance.FailSendReqMaster(m_tmkReqInfo.faxId, P_TYPE.TMK, Config.SYSTEM_PROCESS_ID) < 0)
{
LogError(string.Format("[FAX_ID:{0}] 작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId));
}
//// DTL 전체실패처리 ////
if (DbModule.Instance.FailSendReqDetail(m_tmkReqInfo.faxId, -1, P_TYPE.TMK, Config.SYSTEM_PROCESS_ID, result) < 0)
{
LogError(string.Format("[FAX_ID:{0}] 작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId));
}
continue;
}
LogMessage(string.Format("[FAX_ID:{0}] 팩스폼다운로드성공 (파일:{1} -> {2})", m_tmkReqInfo.faxId, strSrcFaxFormFullName, strLocalFaxFormFullName), result);
foreach (DbModule.SEND_REQUEST_DTL_TMK tmkDtlReqInfo in m_tmkReqInfo.m_lstTmkSendRequestDtlInfos)
{
//// TIFF생성 - 실패시 3회처리 ////
result = RESULT.EMPTY;
for (int i = 0; i < 3; i++)
{
result = MakingTiff(m_tmkReqInfo.faxId,
m_tmkReqInfo.strTrNo,
m_tmkReqInfo.m_strPacket,
strLocalFaxFormFullName,
strSrcFaxFormFullName,
tmkDtlReqInfo,
docInfoAll,
nextProcessType);
if (result == RESULT.SUCCESS)
{
break;
}
LogError(string.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}] TIF파일 생성실패 (횟수:{2})", m_tmkReqInfo.faxId, tmkDtlReqInfo.faxDtlId, i + 1), result);
Thread.Sleep(500);
}
if (result != RESULT.SUCCESS)
{
if (DbModule.Instance.FailSendReqDetail(tmkDtlReqInfo.faxId, tmkDtlReqInfo.faxDtlId, P_TYPE.TMK, Config.SYSTEM_PROCESS_ID, result) < 0)
{
LogError(string.Format("[FAX_ID:{0}] 작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId), RESULT.F_DB_UPDATE_ERROR);
}
continue;
}
//// DTL성공 처리 ////
if (DbModule.Instance.SuccessSendReqDetail(m_tmkReqInfo.faxId, tmkDtlReqInfo.faxDtlId, P_TYPE.TMK, Config.SYSTEM_PROCESS_ID) < 0)
{
LogError(string.Format("[FAX_ID:{0}] 작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId), RESULT.F_DB_UPDATE_ERROR);
continue;
}
//// 성공건 추가 ////
m_lstSuccessTmkDtlReqs.Add(tmkDtlReqInfo);
Thread.Sleep(100);
}
File.Delete(strLocalFaxFormFullName);
if (m_lstSuccessTmkDtlReqs.Count <= 0)
{
result = RESULT.F_MAKE_IMAGEFILE_NOT_EXIST;
LogError(string.Format("[FAX_ID:{0}] TIF생성 성공건이 존재하지 않습니다", m_tmkReqInfo.faxId), result);
if (DbModule.Instance.FailSendReqMaster(m_tmkReqInfo.faxId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID) < 0)
{
LogError(string.Format("[FAX_ID:{0}] 작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId));
}
continue;
}
if (docInfoExistInDb)
{
//// 생성 TIFF DB 에 업데이트 ////
if (!DbModule.Instance.FinishProcessingDoc(Config.PROCESS_TYPE, docInfoAll.seq))
{
LogError(string.Format("[FAX_ID:{0}] TIF파일 생성정보를 DB에 UPDATE 하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId), RESULT.F_DB_UPDATE_ERROR);
continue;
}
}
else
{
//// 생성 TIFF DB 에 추가 ////
if (!DbModule.Instance.InsertSendDoc(m_tmkReqInfo.faxId, Config.PROCESS_TYPE, ".", docInfoAll))
{
LogError("생성TIF 정보를 DB에 INSERT 하는 도중 오류가 발생하였습니다", RESULT.F_DB_UPDATE_ERROR);
continue;
}
}
//// 다음 프로세스로 전달 - BTF_FAX_SEND_DTL ////
if (DbModule.Instance.PassoverDetailSendReq(m_tmkReqInfo.faxId, -1, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, nextProcessType, "N") <= 0)
{
LogError(string.Format("[FAX_ID:{0}] 작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId), RESULT.F_DB_UPDATE_ERROR);
continue;
}
//// 다음 프로세스로 전달 - BTF_FAX_SEND_MSTR ////
if (DbModule.Instance.PassoverMasterSendReq(m_tmkReqInfo.faxId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, nextProcessType) <= 0)
{
LogError(string.Format("[FAX_ID:{0}] 작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", m_tmkReqInfo.faxId), RESULT.F_DB_UPDATE_ERROR);
continue;
}
//// 로그 기록 ////
LogMessage(string.Format("[FAX_ID:{0}] TIF파일 생성작업 완료", m_tmkReqInfo.faxId, strSrcFaxFormFullName, strLocalFaxFormFullName), RESULT.SUCCESS);
Thread.Sleep(QUEUE_POLLING_SLEEP);
}
}
private RESULT MakingTiff(decimal p_faxId,
string p_strTrNo,
string p_strPacket,
string p_strFaxFormLocal,
string p_strFaxFormFullPath,
DbModule.SEND_REQUEST_DTL_TMK p_tmkDtlInfo,
DbModule.DOC_INFO_ALL_TMK p_docInfo,
P_TYPE p_destProcessType)
{
RESULT result = RESULT.EMPTY;
// ADD - KIMCG : 20140903
// 팩스번호 복호화 처리
if (Config.ENCRYPT_FIELD_YN == "Y")
{
string strDecrytedFaxNo = "";
if (EncryptApi.Decrypt(p_tmkDtlInfo.strFaxNo, out strDecrytedFaxNo))
{
p_tmkDtlInfo.strFaxNo = strDecrytedFaxNo;
}
else
{
LogWrite(LOG_LEVEL.WRN, "팩스번호 복호화 처리 실패", RESULT.EMPTY);
}
}
// ADD - END
if (p_destProcessType == P_TYPE.PSC)
{
p_docInfo.strDocFile = string.Format("{0}_{1}", p_faxId, p_tmkDtlInfo.faxDtlId);
}
else
{
p_docInfo.strDocFile = string.Format("{0}_{1}_tifmake", p_faxId, p_tmkDtlInfo.faxDtlId);
}
string strFileName = string.Format("{0}.{1}", p_docInfo.strDocFile, p_docInfo.strDocExt);
//// 파일경로이름 SET ////
string strFinishFile = "";
string strMakingFile = string.Format(@"{0}\{1}", Config.TIFF_MAKING_PATH, strFileName);
if (p_destProcessType == P_TYPE.PSC)
{
strFinishFile = string.Format(@"{0}\{1}", Config.FINISHED_TIF_PATH, p_tmkDtlInfo.strTiffPath);
}
else
{
strFinishFile = string.Format(@"{0}\{1}", Config.MADE_TIF_PATH, strFileName);
}
string strPacketXmlFile = string.Format(@"{0}\{1}_{2}.xml", Config.TIFF_MAKING_PATH, p_faxId, p_tmkDtlInfo.faxDtlId);
//// TIFF 생성 ////
try
{
//// 팩스폼 로딩 ////
if (!File.Exists(p_strFaxFormLocal))
{
LogError(string.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}] 팩스폼파일을 찾을수 없습니다.(파일:{2})", p_faxId, p_tmkDtlInfo.faxDtlId, p_strFaxFormLocal), RESULT.F_MAKE_NOT_EXIST_FAXFORMFILE);
return(RESULT.F_MAKE_NOT_EXIST_FAXFORMFILE);
}
//// Page fault 처리 - 스트림 생성 ////
using (MemoryStream faxFormStream = new MemoryStream())
{
using (Stream localFaxFormStream = File.OpenRead(p_strFaxFormLocal))
{
localFaxFormStream.CopyTo(faxFormStream);
localFaxFormStream.Close();
}
using (XtraReport_Btfax report = new XtraReport_Btfax())
{
report.LoadLayout(p_strFaxFormLocal);
LogMessage(string.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}] 팩스폼파일 로딩성공 (파일:{2})", p_faxId, p_tmkDtlInfo.faxDtlId, p_strFaxFormLocal), RESULT.SUCCESS);
//// 전문 XML 로딩 ////
report.LoadPacketXml(p_strPacket, p_strTrNo, false, true);
//// 레포트 데이터셋에 팩스번호, 수신인명 바인딩 처리 ////
DataSet reportDs = report.DataSource as DataSet;
if (reportDs == null)
{
LogError(string.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}] 팩스폼에 데이터셋이 존재하지 않습니다 (파일:{2})", p_faxId, p_tmkDtlInfo.faxDtlId, p_strFaxFormLocal), RESULT.F_MAKE);
return(RESULT.F_MAKE);
}
DataTable reportDt = reportDs.Tables["헤더___HEADER_O_COMMON"];
if (reportDt == null)
{
LogError(string.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}] 팩스폼에 데이터셋이 존재하지 않습니다 (파일:{2})", p_faxId, p_tmkDtlInfo.faxDtlId, p_strFaxFormLocal), RESULT.F_MAKE);
return(RESULT.F_MAKE);
}
bool bFaxNumBinded = false;
bool bFaxRecipientNameBinded = false;
foreach (DataColumn col in reportDt.Columns)
{
foreach (DataRow row in reportDt.Rows)
{
if (bFaxNumBinded && bFaxRecipientNameBinded)
{
break;
}
if (col.ColumnName == "수신자팩스번호")
{
row[col.ColumnName] = p_tmkDtlInfo.strFaxNo;
bFaxNumBinded = true;
}
if (col.ColumnName == "수신자이름")
{
row[col.ColumnName] = p_tmkDtlInfo.strRecipientName;
bFaxRecipientNameBinded = true;
}
}
}
//// 컨트롤 바인딩 처리 ////
foreach (Band band in report.Bands)
{
foreach (XRControl control in band.Controls)
{
//// 이미지 외, 컨트롤 바인딩 유효성 체크 ////
if (control is XRLabel || control is XRCheckBox || control is XRTableCell)
{
result = ValidateBinding(report, control);
if (result != RESULT.SUCCESS)
{
return(result);
}
}
//// 이미지 바인딩 유효성 체크 및 동적 바인딩 ////
else if (control is XRPictureBox)
{
XRPictureBox xrPictureBox = control as XRPictureBox;
result = BindImageBox(report, xrPictureBox);
if (result != RESULT.SUCCESS)
{
throw new Exception();
}
}
}
}
//// Export ///
//report.ExportToImage(strMakingFile, this.exportOption);
if (!report.ExportImageForFax(Config.TIFF_MAKING_PATH, strFileName))
{
LogError(string.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}] TIF파일 생성실패 (파일:{2})", p_faxId, p_tmkDtlInfo.faxDtlId, strMakingFile), RESULT.F_MAKE);
return(RESULT.F_MAKE);
}
LogMessage(string.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}] TIF파일 생성성공 (파일:{2})", p_faxId, p_tmkDtlInfo.faxDtlId, strMakingFile), RESULT.SUCCESS);
//// 파일 업로드 ////
if (!UploadFinishedTif(strMakingFile, strFinishFile))
{
LogError(string.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}] TIF파일 업로드실패 (파일:{2}->{3})", p_faxId, p_tmkDtlInfo.faxDtlId, strMakingFile, strFinishFile), RESULT.F_FILE_FAIL_TO_UPLOAD);
return(RESULT.F_FILE_FAIL_TO_UPLOAD);
}
LogMessage(string.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}] TIF파일 업로드성공 (파일:{2}->{3})", p_faxId, p_tmkDtlInfo.faxDtlId, strMakingFile, strFinishFile), RESULT.SUCCESS);
if (reportDt != null)
{
reportDt.Dispose();
}
if (reportDs != null)
{
reportDs.Dispose();
}
// LHOPE
File.Delete(strMakingFile);
}
faxFormStream.Close();
return(RESULT.SUCCESS);
}
}
catch (Exception ex)
{
LogError(string.Format("팩스 발송 요청에 대하여 팩스폼[{0}]으로 TIFF 파일[{1}]을 생성하는 도중., 다음과 같은 오류가 발생하였습니다. {2}",
p_strFaxFormFullPath, strMakingFile, ex.Message), RESULT.F_MAKE);
return(RESULT.F_MAKE);
}
}
protected RESULT HandleBeforeWeb(DbModule.SEND_REQUEST_PSC p_Request)
{
P_TYPE destProcessType = P_TYPE.NONE;
R_STATE state = R_STATE.INIT;
//int nState = 0;
//// Beffore처리 1. 문서필터링 처리 ////
if (PostFcs.Util.Config.DOC_FILTERING_YN == "Y")
{
#region TO - DO
#endregion
}
//// Before처리 2. TIF 크기, 페이지 SET ////
long lTiffFileSize = -1;
int nTiffPageCnt = -1;
foreach (DbModule.SEND_REQUEST_DTL_PSC dtlReq in m_pscReqInfo.m_lstSendRequestDtlPscInfos)
{
string strLocalTiffFullName = "";
string logExtMsg = String.Format("[FAX_ID:{0}][FAX_DTL_ID:{1}][FAX_NO:{2}]",
dtlReq.faxId
, dtlReq.faxDtlId
, dtlReq.strFaxNo
);
if (!DownloadTiffFile(dtlReq, out strLocalTiffFullName))
{
LogError(String.Format("TIF다운로드 실패 [RESULT:{0}]{1}", RESULT.F_FILE_NOT_EXIST, logExtMsg));
continue;
}
LogMessage(String.Format("TIF파일 다운로드 완료 [RESULT:{0}]{1}", RESULT.SUCCESS, logExtMsg));
if (!GetTiffFileNames(dtlReq, strLocalTiffFullName))
{
dtlReq.strStateEach = R_STATE.PSC_F.ToString();
LogError(String.Format("TIF파일명 정보를 알수없습니다 [RESULT:{0}]{1}", RESULT.F_FILE_NOT_EXIST, logExtMsg));
if (DbModule.Instance.FailSendReqDetail(m_pscReqInfo.faxId, dtlReq.faxDtlId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, RESULT.F_FILE_NOT_EXIST) < 0)
{
LogError(String.Format("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다 [RESULT:{0}]{1}", RESULT.F_DB_ERROR, logExtMsg));
}
continue;
}
lTiffFileSize = GetFileSize(dtlReq.strTiffFullName);
if (lTiffFileSize < 0)
{
dtlReq.strStateEach = R_STATE.PSC_F.ToString();
LogError(String.Format("TIF사이즈 정보를 알수없습니다 [RESULT:{0}]{1}", RESULT.F_FILE_FAIL_GET_FILE_SIZE, logExtMsg));
if (DbModule.Instance.FailSendReqDetail(m_pscReqInfo.faxId, dtlReq.faxDtlId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, RESULT.F_FILE_FAIL_GET_FILE_SIZE) < 0)
{
LogError(String.Format("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다 [RESULT:{0}]{1}", RESULT.F_DB_ERROR, logExtMsg));
}
continue;
}
LogMessage(String.Format("TIF파일 사이즈 > {0} [RESULT:{1}]{2}", lTiffFileSize, RESULT.SUCCESS, logExtMsg));
nTiffPageCnt = GetPageCount(dtlReq.strTiffFullName);
if (nTiffPageCnt < 0)
{
dtlReq.strStateEach = R_STATE.PSC_F.ToString();
LogError(String.Format("TIF페이지수 정보를 알수없습니다 [RESULT:{0}]{1}", RESULT.F_FILE_FAIL_GET_FILE_SIZE, logExtMsg));
if (DbModule.Instance.FailSendReqDetail(m_pscReqInfo.faxId, dtlReq.faxDtlId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, RESULT.F_FILE_FAIL_GET_FILE_SIZE) < 0)
{
LogError(String.Format("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다 [RESULT:{0}]{1}", RESULT.F_DB_ERROR, logExtMsg));
}
continue;
}
LogMessage(String.Format("TIF파일 페이지수 > {0} [RESULT:{1}]{2}", nTiffPageCnt, RESULT.SUCCESS, logExtMsg));
if (!DbModule.Instance.UpdateTifInfo(m_pscReqInfo.faxId, dtlReq.faxDtlId, dtlReq.strTiffPath, (int)lTiffFileSize, nTiffPageCnt))
{
LogError(String.Format("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다 [RESULT:{0}]{1}", RESULT.F_DB_ERROR, logExtMsg));
continue;
}
//// 파일사이즈 제한 ////
if (lTiffFileSize > Config.TIF_FILE_MAX_SIZE)
{
LogError(String.Format("발송가능한 파일크기를 초과하였습니다. TIF크기/최대크기:{0}/{1}", lTiffFileSize, Config.TIF_FILE_MAX_SIZE));
if (DbModule.Instance.FailSendReqDetail(m_pscReqInfo.faxId, dtlReq.faxDtlId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, RESULT.F_FILE_FAIL_FILE_SIZE_OVERFLOW) < 0)
{
LogError(String.Format("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다 [RESULT:{0}]{1}", RESULT.F_FILE_FAIL_FILE_SIZE_OVERFLOW, logExtMsg));
}
continue;
}
//// DownloadTIFF 파일 삭제 ////
if (File.Exists(strLocalTiffFullName))
{
File.Delete(strLocalTiffFullName);
}
m_lstSuccReqDtls.Add(dtlReq);
}
LogMessage(String.Format("변환후 처리 [전체:{0}] [성공:{1}] [실패:{2}]",
m_pscReqInfo.m_lstSendRequestDtlPscInfos.Count,
m_lstSuccReqDtls.Count,
(m_pscReqInfo.m_lstSendRequestDtlPscInfos.Count - m_lstSuccReqDtls.Count)
));
if (m_lstSuccReqDtls.Count <= 0)
{
if (DbModule.Instance.FailSendReqMaster(m_pscReqInfo.faxId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID) < 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
}
LogMessage(String.Format("[RESULT:{0}] MSTER 실패건 처리완료 [FAX_ID:{1}][TR_NO:{2}][REQ_TYPE:{3}][PREVIEW_REQ:{4}][APPROVE_REQ:{5}]",
RESULT.SUCCESS,
m_pscReqInfo.faxId,
m_pscReqInfo.strTrNo,
m_pscReqInfo.strReqType,
m_pscReqInfo.previewYN,
m_pscReqInfo.approvedReq
));
return(RESULT.SUCCESS);
}
//// 미리보기, 승인 건이 아닌경우, AfterWEB 에서 처리 ////
if (m_pscReqInfo.previewYN.ToUpper() != "Y" && m_pscReqInfo.approvedReq.ToUpper() != "Y")
{
//예약발송이면 PSC후처리대기상태로 가도록 처리
if (m_pscReqInfo.reserveYN.ToUpper() == "Y")
{
destProcessType = P_TYPE.WEB;
state = R_STATE.PSC_WS;
foreach (DbModule.SEND_REQUEST_DTL dtlReq in m_lstSuccReqDtls)
{
if (DbModule.Instance.PassoverDetailSendReq(m_pscReqInfo.faxId, dtlReq.faxDtlId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, destProcessType, "N", state) <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
continue;
}
}
if (DbModule.Instance.PassoverMasterSendReq(m_pscReqInfo.faxId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, destProcessType, state) <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
return(RESULT.F_DBP_FAIL_PASS_OVER_SEND_REQ_MSTR);
}
LogMessage(String.Format("[RESULT:{0}] 전처리 작업 완료 [FAX_ID:{1}][TR_NO:{2}][REQ_TYPE:{3}][PREVIEW_REQ:{4}][APPROVE_REQ:{5}]",
RESULT.SUCCESS,
m_pscReqInfo.faxId,
m_pscReqInfo.strTrNo,
m_pscReqInfo.strReqType,
m_pscReqInfo.previewYN,
m_pscReqInfo.approvedReq
));
return(RESULT.SUCCESS);
}
return(HandleAfterWeb(p_Request));
}
//승인 대기Y && 미리보기N 건인 경우 FAXBOX로 Insert
if (m_pscReqInfo.approvedReq.ToUpper() == "Y" && m_pscReqInfo.previewYN.ToUpper() == "N")
{
if (!DbModule.Instance.InsertFaxbox(m_pscReqInfo.faxId))
{
//실패처리
if (DbModule.Instance.FailSendReqMaster(m_pscReqInfo.faxId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID) < 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
}
LogMessage(String.Format("[RESULT:{0}] 승인대기건 FAXBOX로 이동중 실패건 처리완료 [FAX_ID:{1}][TR_NO:{2}][REQ_TYPE:{3}][PREVIEW_REQ:{4}][APPROVE_REQ:{5}]",
RESULT.SUCCESS,
m_pscReqInfo.faxId,
m_pscReqInfo.strTrNo,
m_pscReqInfo.strReqType,
m_pscReqInfo.previewYN,
m_pscReqInfo.approvedReq
));
return(RESULT.SUCCESS);
}
}
//// 미리보기, 승인 건인 경우, WEB 으로 전달 ////
destProcessType = P_TYPE.WEB;
state = (m_pscReqInfo.previewYN == "Y") ? R_STATE.PSC_WP : R_STATE.PSC_WA;
foreach (DbModule.SEND_REQUEST_DTL dtlReq in m_lstSuccReqDtls)
{
if (DbModule.Instance.PassoverDetailSendReq(m_pscReqInfo.faxId, dtlReq.faxDtlId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, destProcessType, "N", state) <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
continue;
}
}
if (DbModule.Instance.PassoverMasterSendReq(m_pscReqInfo.faxId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, destProcessType, state) <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
return(RESULT.F_DBP_FAIL_PASS_OVER_SEND_REQ_MSTR);
}
LogMessage(String.Format("[RESULT:{0}] 후처리 작업 완료 [FAX_ID:{1}][TR_NO:{2}][REQ_TYPE:{3}][PREVIEW_REQ:{4}][APPROVE_REQ:{5}]",
RESULT.SUCCESS,
m_pscReqInfo.faxId,
m_pscReqInfo.strTrNo,
m_pscReqInfo.strReqType,
m_pscReqInfo.previewYN,
m_pscReqInfo.approvedReq
));
return(RESULT.SUCCESS);
}
protected RESULT HandleAfterWeb(DbModule.SEND_REQUEST_PSC p_Request)
{
List <DbModule.SEND_REQUEST_DTL_PSC> outInwardList = new List <DbModule.SEND_REQUEST_DTL_PSC>();
P_TYPE destProcessType = P_TYPE.NONE;
R_STATE state = R_STATE.INIT;
string strDid = "";
//미리보기Y && 승인대기Y 이면, 미리보기N으로 UPDATE 후에 PSC대기상태(71)로 변경.
if (m_pscReqInfo.previewYN.ToUpper() == "Y" && m_pscReqInfo.approvedReq.ToUpper() == "Y")
{
if (!DbModule.Instance.UpdatePreviewInfo(m_pscReqInfo.faxId, "N"))
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
return(RESULT.F_DB_UPDATE_ERROR);
}
destProcessType = P_TYPE.WEB;
state = R_STATE.PSC_W;
foreach (DbModule.SEND_REQUEST_DTL dtlReq in m_pscReqInfo.m_lstSendRequestDtlPscInfos)
{
if (DbModule.Instance.PassoverDetailSendReq(m_pscReqInfo.faxId, dtlReq.faxDtlId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, destProcessType, "N", state) <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
continue;
}
}
if (DbModule.Instance.PassoverMasterSendReq(m_pscReqInfo.faxId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, destProcessType, state) <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
return(RESULT.F_DBP_FAIL_PASS_OVER_SEND_REQ_MSTR);
}
LogMessage(String.Format("변환후처리 작업 완료 [FAX_ID:{0}][TR_NO:{1}][REQ_TYPE:{2}][PREVIEW_REQ:{3}][APPROVE_REQ:{4}]",
m_pscReqInfo.faxId,
m_pscReqInfo.strTrNo,
m_pscReqInfo.strReqType,
m_pscReqInfo.previewYN,
m_pscReqInfo.approvedReq
));
return(RESULT.SUCCESS);
}
//// 결과 성공 처리 ////
if (DbModule.Instance.SuccessSendReqDetail(m_pscReqInfo.faxId, -1, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID) < 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
return(RESULT.F_DB_UPDATE_ERROR);
}
//// 내부 발송 처리 ////
foreach (DbModule.SEND_REQUEST_DTL_PSC dtlReq in m_pscReqInfo.m_lstSendRequestDtlPscInfos)
{
//팩스 번호에서 '-' 제거
dtlReq.strFaxNo = dtlReq.strFaxNo.Replace("-", "");
strDid = "";
// ADD - KIMCG : 20150914
// LOOP_FAXNO 일경우 FOD로 전달.
if (dtlReq.strFaxNo == Config.LOOP_FAXNO)
{
LogMessage(String.Format("[RESULT:{0}] LOOP FAX [FAX_ID:{1}][TR_NO:{2}][REQ_TYPE:{3}][PREVIEW_REQ:{4}][APPROVE_REQ:{5}]",
RESULT.EMPTY,
m_pscReqInfo.faxId,
m_pscReqInfo.strTrNo,
m_pscReqInfo.strReqType,
m_pscReqInfo.previewYN,
m_pscReqInfo.approvedReq
));
continue;
}
// ADD - END
// 내부 팩스 번호가 아니면, SKIP.
if (!DbModule.Instance.IsInboundFaxNo(dtlReq.strFaxNo, ref strDid))
{
continue;
}
// 내부 발송 건 추가
outInwardList.Add(dtlReq);
// 내부 발송 처리
RESULT result = ProcessInbound(dtlReq, strDid);
// 발송 MSTR/DTL DATA 테이블로 이동
if (!DbModule.Instance.FinishIBSendDtl(Config.SYSTEM_NO, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, m_pscReqInfo.strBroadcastYN, dtlReq, result))
{
LogError("인바운드 케이스를 Data테이블로 이동하는 도중 오류가 발생하였습니다");
return(RESULT.F_DB_UPDATE_ERROR);
}
}
// 내부 발송 처리 완료 건, 제외
foreach (DbModule.SEND_REQUEST_DTL_PSC dtlReq in outInwardList)
{
m_pscReqInfo.m_lstSendRequestDtlPscInfos.Remove(dtlReq);
}
// 모두 내부 발송이면, 처리 종료.
if (m_pscReqInfo.m_lstSendRequestDtlPscInfos.Count <= 0)
{
LogMessage(String.Format("[RESULT:{0}] 후처리 작업 완료 [FAX_ID:{1}][TR_NO:{2}][REQ_TYPE:{3}][PREVIEW_REQ:{4}][APPROVE_REQ:{5}]",
RESULT.SUCCESS,
m_pscReqInfo.faxId,
m_pscReqInfo.strTrNo,
m_pscReqInfo.strReqType,
m_pscReqInfo.previewYN,
m_pscReqInfo.approvedReq
));
return(RESULT.SUCCESS);
}
////외부 발송 처리 : FOD로 전달 ////
destProcessType = P_TYPE.FOD;
state = R_STATE.FOD_W;
foreach (DbModule.SEND_REQUEST_DTL dtlReq in m_pscReqInfo.m_lstSendRequestDtlPscInfos)
{
if (DbModule.Instance.PassoverDetailSendReq(m_pscReqInfo.faxId, dtlReq.faxDtlId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, destProcessType, "N", state) <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
continue;
}
}
if (DbModule.Instance.PassoverMasterSendReq(m_pscReqInfo.faxId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, destProcessType, state) <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다");
return(RESULT.F_DBP_FAIL_PASS_OVER_SEND_REQ_MSTR);
}
LogMessage(String.Format("변환후처리 작업 완료 [FAX_ID:{0}][TR_NO:{1}][REQ_TYPE:{2}][PREVIEW_REQ:{3}][APPROVE_REQ:{4}]",
m_pscReqInfo.faxId,
m_pscReqInfo.strTrNo,
m_pscReqInfo.strReqType,
m_pscReqInfo.previewYN,
m_pscReqInfo.approvedReq
));
return(RESULT.SUCCESS);
}
public RESULT PSI_FetchPostProcessingRequest(P_TYPE p_processType, string p_strSystemProcessId, int p_occupyCnt, ref List <RECV_FAX_DATA_PSI> p_result)
{
RESULT ret = RESULT.EMPTY;
string strProcedureName = "PKG_PRC_PSI.USP_PROCESS_POST_INBOUND";
lock (m_connection)
{
if (!ReOpen())
{
return(RESULT.F_DB_OPENERROR);
}
try
{
using (OracleCommand command = new OracleCommand())
{
command.Connection = m_connection;
command.CommandText = strProcedureName;
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("P_PROCESS_TYPE", p_processType.ToString());
command.Parameters.AddWithValue("P_FETCH_PROCESS", p_strSystemProcessId);
command.Parameters.AddWithValue("P_OCCUPY_CNT", p_occupyCnt);
OracleParameter param1 = new OracleParameter("P_TABLE1", OracleType.Cursor);
param1.Direction = ParameterDirection.Output;
command.Parameters.Add(param1);
OracleParameter param2 = new OracleParameter("P_TABLE2", OracleType.Cursor);
param2.Direction = ParameterDirection.Output;
command.Parameters.Add(param2);
using (OracleDataReader reader = command.ExecuteReader())
{
DataTable dt = new DataTable();
dt.Load(reader);
DataTable dt2 = new DataTable();
dt2.Load(reader);
/// dt, dt2 outer join 과 같은 결과를 내기 위한 loop
foreach (DataRow dr in dt.Rows)
{
RECV_FAX_DATA_PSI data = new RECV_FAX_DATA_PSI();
data.FAX_ID = decimal.Parse(dr["FAX_ID"].ToString());
//data.DEPT_CD = dr["OWNER_DEPT_CD"].ToString(); //WCD(2014-05-28) 부서정보 조회
//data.DEPT_NAME = dr["OWNER_DEPT_NAME"].ToString(); //WCD(2014-05-28) 부서정보 조회
// TEST - 추후 주석제거
//data.DEPT_CD = dr["UPPER_DEPT_CD"].ToString(); //WCD(2014-05-28)
//data.DEPT_NAME = dr["UPPER_DEPT_NAME"].ToString(); //WCD(2014-05-28)
//data.TASK_ID = dr["OWNER_TASK_ID"].ToString();
// TEST
//if(!decimal.TryParse(dr["OWNER_TASK_ID"].ToString(), out data.TASK_ID))
// data.TASK_ID = 0;
data.TASK_NAME = dr["OWNER_TASK_NAME"].ToString();
data.USER_ID = dr["OWNER_USER_ID"].ToString();
// TEST - 추후 주석제거
data.USER_NAME = dr["OWNER_USER_NAME"].ToString(); //WCD(2014-04-29)
data.SERVICE_FAXNO = dr["SERVICE_FAXNO"].ToString(); //WCD(2014-04-29)
data.DID = dr["DID"].ToString(); //WCD(2014-04-29)
//data.RECV_DATE = string.Format("{0:yyyyMMdd}", dr["RECV_DATE"]);//WCD(2014-04-29)
//data.RECV_TIME = string.Format("{0:HHmm}", dr["RECV_DATE"]); //WCD(2014-04-29)
//data.PAGE_CNT = dr["TIF_PAGE_CNT"].ToString(); //WCD(2014-04-29)
// TEST - 추후 주석제거
data.CID = dr["CID"].ToString();
data.CID_NAME = dr["CID_NAME"].ToString();
data.EMAIL_NOTIFY_YN = dr["EMAIL_NOTIFY_YN"].ToString();
data.EMAIL_NOTIFY = dr["EMAIL_NOTIFY"].ToString();
data.PROXY_USER_ID = dr["PROXY_USER_ID"].ToString();
data.PROXY_USER_ID = dr["PROXY_USER_NAME"].ToString();
data.PROXY_EMAIL_NOTIFY_YN = dr["PROXY_EMAIL_NOTIFY_YN"].ToString();
data.PROXY_EMAIL_NOTIFY = dr["PROXY_EMAIL_NOTIFY"].ToString();
data.SPAM_YN = dr["SPAM_YN"].ToString();
foreach (DataRow dr2 in dt2.Rows)
{
decimal fax_id = decimal.Parse(dr2["FAX_ID"].ToString());
if (data.FAX_ID == fax_id)
{
data.SUCC_YN = dr2["SUCC_YN"].ToString();
break;
}
}
p_result.Add(data);
}
}
if (p_result.Count > 0)
{
ret = RESULT.SUCCESS;
}
}
}
catch (Exception ex)
{
ExceptionMsg(ex, "PROCEDURE : " + strProcedureName);
ret = RESULT.F_SYSTEM_ERROR;
}
}
return(ret);
}
/// <summary>
/// Name : PollingLoop_
/// Parameters : Empty
/// Content : 폴링 루프
/// Return : Empty
/// Writer : 장동훈
/// Date : 2012.09.03
/// </summary>
private void PollingLoop_()
{
DbModule.SendRequestMasterInfo reqInfo_mstr = new DbModule.SendRequestMasterInfo();
DbModule.SendRequestDetailInfo reqInfo_dtl = new DbModule.SendRequestDetailInfo();
DbModule.SEND_REQ_SITE reqInfo_site = new DbModule.SEND_REQ_SITE();
P_TYPE destProcessType = P_TYPE.PSC;
FileInfo fi = null;
string[] files = null;
string[] checkFiles = null;
string[] workFiles = null;
int successCount = 0;
string destFileName = null; // Detail 테이블에 기록될 Unique 파일 이름
try
{
/// 에러로 인해 Process -> Finish 처리가 안된 팩스들 Process 폴더 -> Upload 폴더로 이동
CheckProcessFolder();
/// Storage 경로 확인
if (CheckStoragePath() == false)
{
return;
}
while (!BtfaxThread.Stop)
{
/// 초기화
files = null;
checkFiles = null;
workFiles = null;
successCount = 1;
destFileName = null;
/// 파일 업로드 여부 확인
if (CheckUploadFiles(ref files, ref checkFiles, ref workFiles) == true)
{
foreach (string f in checkFiles)
{
/// 한번에 처리할 최대 개수
if (successCount++ > Config.FILE_PROCESS_COUNT)
{
break;
}
/// 초기 설정
fi = new FileInfo(f);
reqInfo_mstr.Clear();
reqInfo_dtl.Clear();
reqInfo_site.clear();
try
{
Thread.Sleep(100);
/// 작업할 파일 작업폴더로 이동
if (FileMove(fi, FileMoveLocationEnum.Process, ref destFileName) == false)
{
continue;
}
/// 파일 파싱
if (ParseTifFile(fi, reqInfo_mstr, reqInfo_dtl) == false)
{
continue;
}
/// 파싱 성공 후 이미지 폴더로 파일 이동 (+ 이름 변경)
if (FileMove(fi, FileMoveLocationEnum.Done, ref destFileName) == false)
{
continue;
}
/// DB 에 저장될 파일명 변경
if (FileRenameForDB(reqInfo_dtl, destFileName) == false)
{
continue;
}
/// DB Insert
if (InsertToDb(reqInfo_mstr, reqInfo_dtl, reqInfo_site) != RESULT.SUCCESS)
{
continue;
}
/// Pass Over
if (PassOverSendRequest(destProcessType, reqInfo_mstr, reqInfo_dtl) != RESULT.SUCCESS)
{
continue;
}
}
catch (Exception ex)
{
AppLog.ExceptionLog(ex, string.Format("{0} 쓰레드에서 다음과 같은 오류가 발생하였습니다.", m_ThreadName));
break;
}
}
}
/// Wait - Storage polling time
/// Sleep 시간이 길 경우 Thread.Join() 도 길어져 Sleep 시간을 줄임
for (int i = 0; !BtfaxThread.Stop && (i * 100 < Config.SOTRAGE_POLLING_TIME); i++)
{
Thread.Sleep(100);
}
}
}
catch (Exception ex)
{
AppLog.ExceptionLog(ex, string.Format("{0} 쓰레드에서 다음과 같은 오류가 발생하였습니다. 쓰레드를 종료합니다.", m_ThreadName));
//throw ex;
}
}
protected override void ThreadEntry()
{
AppLog.Write(LOG_LEVEL.MSG, "### DB폴링 쓰레드 시작 ###");
Thread.Sleep(Config.INITIAL_SLEEP);
AppLog.Write(LOG_LEVEL.MSG, "### DB폴링 시작 ###");
ReadySendReq();
while (!BtfaxThread.Stop)
{
Thread.Sleep(Config.DB_POLLING_SLEEP);
ClearReqInfo();
if (!ExistsFaxStorage())
{
AppLog.Write(LOG_LEVEL.ERR, string.Format("팩스스토리지를 찾을수 없습니다. 위치:{0}", Config.STG_HOME_PATH));
continue;
}
//// 변환 요청 건 조회 ////
RESULT result = DbModule.Instance.FetchSendReqToConvert(ref m_lstSendReqDcvInfos);
switch (result)
{
case RESULT.EMPTY:
case RESULT.SUCCESS:
break;
default:
AppLog.Write(LOG_LEVEL.ERR, "DB 폴링 중 오류가 발생하였습니다");
continue;
}
LogMessage("DbPolling Check..");
if (m_lstSendReqDcvInfos.Count <= 0)
{
continue;
}
foreach (DbModule.SEND_REQUEST_DCV dcvReqInfo in m_lstSendReqDcvInfos)
{
string logInfo = string.Format("[FAX_ID:{0}][TR_NO:{1}][REQ_TYPE:{2}]", dcvReqInfo.faxId, dcvReqInfo.strTrNo, dcvReqInfo.strReqType);
LogMessage(string.Format("변환요청건 점유 {0}", logInfo));
//// 다음 프로세스 유형 SET ////
P_TYPE nextProcessType = P_TYPE.NONE;
switch (Convert.ToInt32(dcvReqInfo.strReqType))
{
case (int)REQ_TYPE.DCV: nextProcessType = P_TYPE.PSC; break;
case (int)REQ_TYPE.DCV_TPC: nextProcessType = P_TYPE.TPC; break;
case (int)REQ_TYPE.TMK_DCV_TPC: nextProcessType = P_TYPE.TPC; break;
//default
default:
result = DbModule.Instance.FailSendReqs(dcvReqInfo.faxId, -1, Config.PROCESS_TYPE, Config.PROCESS_ID, RESULT.F_REQ_TYPE_ERROR);
if (result != RESULT.SUCCESS)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", result);
}
continue;
}
//// 변환 작업 ////
result = ConvertDocs(dcvReqInfo, dcvReqInfo.m_lstDocInfoAllDcv, nextProcessType);
if (result != RESULT.SUCCESS)
{
LogError(string.Format("문서변환 실패({0}) {1}", result, logInfo));
result = DbModule.Instance.FailSendReqs(dcvReqInfo.faxId, -1, Config.PROCESS_TYPE, Config.PROCESS_ID, RESULT.F_REQ_TYPE_ERROR);
if (result != RESULT.SUCCESS)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", result);
}
continue;
}
LogMessage(string.Format("문서변환 성공 {0}", logInfo), RESULT.SUCCESS);
//// 성공 결과 DB 반영 ////
foreach (DbModule.SEND_REQUEST_DTL_DCV dtlReq in dcvReqInfo.m_lstSendRequestDtlDcvInfos)
{
if (DbModule.Instance.SuccessSendReqDetail(dcvReqInfo.faxId, dtlReq.faxDtlId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID) < 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", RESULT.F_DB_UPDATE_ERROR);
continue;
}
}
//// DETAIL건 파일명 전체업데이트 ////
if (!DbModule.Instance.UpdateAllTifName(dcvReqInfo.faxId, dcvReqInfo.strLastTifFile))
{
LogError("전체 TIF파일명을 업데이트하는 도중 오류가 발생하였습니다", RESULT.F_DB_UPDATE_ERROR);
continue;
}
//// DETAIL 전체 Pass over ////
if (DbModule.Instance.PassoverDetailSendReq(dcvReqInfo.faxId, -1, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, nextProcessType, "N") <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", RESULT.F_DB_UPDATE_ERROR);
continue;
}
//// MSTR Pass over ////
if (DbModule.Instance.PassoverMasterSendReq(dcvReqInfo.faxId, Config.PROCESS_TYPE, Config.SYSTEM_PROCESS_ID, nextProcessType) <= 0)
{
LogError("작업완료 상태를 DB에 반영하는 도중 오류가 발생하였습니다", RESULT.F_DB_ERROR);
continue;
}
LogMessage(string.Format("변환요청 처리완료 {0}", logInfo), RESULT.SUCCESS);
}
}
AppLog.Write(LOG_LEVEL.MSG, "### 쓰레드 종료 ###");
}
//private bool UploadFinishedTif(string p_strSrcFileName, string p_strDestFileName)
//{
// return CopyFile(p_strSrcFileName, p_strDestFileName);
//}
RESULT ConvertDoc(DbModule.SEND_REQUEST_DCV p_sendReqInfo, P_TYPE p_destProcessType, decimal p_faxId, string p_strPath, string p_strFile, string p_strExt)
{
if (p_sendReqInfo.m_lstSendRequestDtlDcvInfos.Count <= 0)
{
return(RESULT.F_CONV_DOCLIST_NOTEXIST_IN_DB);
}
DbModuleBase.SEND_REQUEST_DTL dtlReq = p_sendReqInfo.m_lstSendRequestDtlDcvInfos[0];
//// 파일 경로/이름 SET ////
if (p_strPath == ".")
{
p_strPath = "";
}
else
{
p_strPath = p_strPath + "\\";
}
string strSourceFile = string.Format("{0}\\{1}{2}.{3}", Config.INPUT_DOCS_PATH, p_strPath, p_strFile, p_strExt);
string strDestFile = string.Format("{0}\\{1}{2}.{3}", Config.TIFF_CONVERTING_PATH, p_strPath, p_strFile, p_strExt);
string strFinishFile;
p_sendReqInfo.strLastTifFile = dtlReq.strTiffPath;
if (p_destProcessType == P_TYPE.PSC)
{
strFinishFile = string.Format("{0}\\{1}", Config.FINISHED_TIF_PATH, dtlReq.strTiffPath);
}
else
{
strFinishFile = string.Format("{0}\\{1}.TIF", Config.CONVERTED_TIF_PATH, p_strFile);
}
//// 변환대상 문서 다운로드 ////
if (!File.Exists(strSourceFile))
{
return(RESULT.F_FILE_NOT_EXIST);
}
if (!DownloadDocFile(strSourceFile, strDestFile))
{
return(RESULT.F_FILE_FAIL_TO_DOWNLOAD);
}
//// 문서포멧 확인 ////
bool isImgFormat = false;
string strConvertedFile = "";
if (PrintingHandler.Instance.IsImageFormat(strDestFile, Config.CONVERT_ABLE_IMG_FORMAT))
{
isImgFormat = true;
}
strConvertedFile = string.Format("{0}\\{1}.TIF", Config.TIFF_CONVERTING_PATH, p_strFile);
//// 문서변환 ////
LogMessage(string.Format("변환처리 ({0}) -> ({1})", strDestFile, strConvertedFile), RESULT.EMPTY);
//// 이미지 포멧일 경우 자체 TIF Conversion ///
if (isImgFormat)
{
if (!PrintingHandler.Instance.Converert(strDestFile, strConvertedFile))
{
LogError(string.Format("TIFF파일을 변환하지 못하였습니다.{0}->{1}", strDestFile, strConvertedFile));
return(RESULT.F_CONV);
}
LogMessage(string.Format("TIFF파일 변환완료 ({0}) -> ({1})", strDestFile, strConvertedFile), RESULT.SUCCESS);
if (!CopyFile(strConvertedFile, strFinishFile))
{
return(RESULT.F_CONV);
}
LogMessage(string.Format("변환된 최종TIF 업로드 성공 ({0}) -> ({1})", strConvertedFile, strFinishFile), RESULT.SUCCESS);
//// 변환이전 로컬 파일 삭제 ////
if (!DeleteFile(strDestFile))
{
LogWarring(string.Format("변환이전 로컬파일({0}) 삭제중 오류가 발생하였습니다.", strDestFile), RESULT.F_CONV);
}
//// 변환된 로컬파일 삭제 ////
if (!DeleteFile(strConvertedFile))
{
LogMessage(string.Format("변환된 로컬파일({0})을 삭제중 오류가 발생하였습니다.", strDestFile), RESULT.F_CONV);
}
// 임시파일 삭제
if (Config.DELETE_INPUT_FILE_YN == "Y")
{
File.Delete(strSourceFile);
LogMessage(string.Format("임시파일({0})을 제거하였습니다.", strSourceFile), RESULT.EMPTY);
}
//// 파일 업로드 성공인 경우, 함수 종료. ////
return(RESULT.SUCCESS);
}
////// 프리터드라이버체크 ////
if (!PrintingHandler.Instance.ExistsPrintDriver(Config.EXEC_PRINT_DRIVER))
{
LogError(string.Format("프린터드라이버({0})가 존재하지 않습니다.", Config.EXEC_PRINT_DRIVER), RESULT.F_CONV);
return(RESULT.F_CONV);
}
// 프리터드라이버 -> 기본프린터로 설정 ////
PrintingHandler.Instance.SetPrinter(Config.EXEC_PRINT_DRIVER);
//// DCV_CALLBACK.EXE 프로세스가 처리하기 위함. ////
if (!File.Exists(Config.DCV_CALLBACK_INI_FILE))
{
LogError(string.Format("파일이 존재하지 않습니다.{0}", Config.DCV_CALLBACK_INI_FILE));
return(RESULT.F_FILE_NOT_EXIST);
}
StringUtil.WritePrivateProfileStringEx(Config.DCV_CALLBACK_INI_FILE, "CONV_INFO", "DCV_OUTPUT", strConvertedFile);
StringUtil.WritePrivateProfileStringEx(Config.DCV_CALLBACK_INI_FILE, "CONV_INFO", "STATE", "READY");
if (!PrintingHandler.Instance.Print(strDestFile))
{
return(RESULT.F_CONV);
}
bool find = false;
string state = "";
int nTurn = Config.CONVERTING_WAIT_TIME / 1000; // 1초마다 파일 존재여부 체크
for (int i = 0; i < nTurn; i++)
{
Thread.Sleep(1000);
state = StringUtil.GetPrivateProfileStringEx(Config.DCV_CALLBACK_INI_FILE, "CONV_INFO", "STATE");
if (!state.Contains("COMPLETED"))
{
continue;
}
if (!File.Exists(strConvertedFile))
{
continue;
}
find = true;
if (!CopyFile(strConvertedFile, strFinishFile))
{
return(RESULT.F_CONV);
}
LogMessage(string.Format("변환된 최종TIF 업로드 성공 ({0}) -> ({1})", strConvertedFile, strFinishFile), RESULT.SUCCESS);
//// 변환이전 로컬 파일 삭제 ////
if (!DeleteFile(strDestFile))
{
LogWarring(string.Format("변환이전 로컬파일({0}) 삭제중 오류가 발생하였습니다.", strDestFile), RESULT.F_CONV);
}
//// 변환된 로컬파일 삭제 ////
if (!DeleteFile(strConvertedFile))
{
LogMessage(string.Format("변환된 로컬파일({0})을 삭제중 오류가 발생하였습니다.", strDestFile), RESULT.F_CONV);
}
// 임시파일 삭제
if (Config.DELETE_INPUT_FILE_YN == "Y")
{
File.Delete(strSourceFile);
LogMessage(string.Format("임시파일({0})을 제거하였습니다.", strSourceFile), RESULT.EMPTY);
}
//// 파일 업로드 성공인 경우, 함수 종료. ////
return(RESULT.SUCCESS);
}
if (find)
{
LogError(string.Format("변환되어진 TIF파일({0})이 대상 경로({1})로 이동되지 못했습니다.", strConvertedFile, strFinishFile), RESULT.F_FILE_FAIL_TO_UPLOAD);
}
LogError(string.Format("문서({0})가 TIF파일로 {1}초동안 변환되지 못하였습니다.", strDestFile, Config.CONVERTING_WAIT_TIME / 1000), RESULT.F_CONV_TIMEOUT);
return(RESULT.F_CONV_TIMEOUT);
}
RESULT ConvertDocs(DbModule.SEND_REQUEST_DCV p_dcvReqInfo, List <DbModule.DOC_INFO_ALL_DCV> p_lstDocInfos, P_TYPE p_destProcessType)
{
foreach (DbModule.DOC_INFO_ALL docInfo in p_lstDocInfos)
{
if (docInfo.strProcessingMode != ((int)DOC_PROCESSING_MODE.DCV).ToString())
{
continue;
}
RESULT result = ConvertDoc(p_dcvReqInfo, p_destProcessType, p_dcvReqInfo.faxId, docInfo.strDocPath, docInfo.strDocFile, docInfo.strDocExt);
if (result != RESULT.SUCCESS)
{
if (!DbModule.Instance.ResultProcessingReq(docInfo.seq, false))
{
LogError("문서변환실패 상태를 DB에 반영하는 도중 오류가 발생하였습니다", RESULT.F_DB_ERROR);
}
return(result);
}
if (!DbModule.Instance.ResultProcessingReq(docInfo.seq, true))
{
LogError("문서변환성공 상태를 DB에 반영하는 도중 오류가 발생하였습니다", RESULT.F_DB_ERROR);
}
}
return(RESULT.SUCCESS);
}
public RESULT FetchSendListToMake(P_TYPE p_processType, string p_strSystemProcessId, int p_occupyCnt, ref List <DbModule.SEND_REQUEST_TMK> p_lstTmkSendReqInfos)
{
RESULT ret = RESULT.EMPTY;
string strProcedureName = "PKG_PRC_TMK.USP_OCCUPY_SEND_REQ";
lock (m_connection)
{
if (!ReOpen())
{
return(RESULT.F_DB_OPENERROR);
}
try
{
using (OracleCommand command = new OracleCommand())
{
command.Connection = m_connection;
command.CommandText = strProcedureName;
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("P_PROCESS_TYPE", p_processType.ToString());
command.Parameters.AddWithValue("P_FETCH_PROCESS", p_strSystemProcessId);
command.Parameters.AddWithValue("P_OCCUPY_CNT", p_occupyCnt);
OracleParameter param = new OracleParameter("P_TABLE1", OracleType.Cursor);
param.Direction = ParameterDirection.Output;
command.Parameters.Add(param);
param = new OracleParameter("P_TABLE2", OracleType.Cursor);
param.Direction = ParameterDirection.Output;
command.Parameters.Add(param);
command.ExecuteNonQuery();
DataTable dtMstr = new DataTable("MSTR");
OracleDataReader reader = (OracleDataReader)command.Parameters["P_TABLE1"].Value;
dtMstr.Load(reader);
reader.Close();
reader.Dispose();
DataTable dtDtl = new DataTable("DETAIL");
reader = (OracleDataReader)command.Parameters["P_TABLE2"].Value;
dtDtl.Load(reader);
reader.Close();
reader.Dispose();
if (dtMstr.Rows.Count <= 0 || dtDtl.Rows.Count <= 0)
{
if (dtMstr != null)
{
dtMstr.Dispose();
}
if (dtDtl != null)
{
dtDtl.Dispose();
}
return(RESULT.EMPTY);
}
//// BTF_FAX_SEND_MSTR ////
foreach (DataRow mstrRow in dtMstr.Rows)
{
SEND_REQUEST_TMK tmkReqInfo = new SEND_REQUEST_TMK();
tmkReqInfo.faxId = (decimal)mstrRow["FAX_ID"];
tmkReqInfo.strTrNo = mstrRow["TR_NO"].ToString();
tmkReqInfo.strState = mstrRow["STATE"].ToString();
tmkReqInfo.strReqType = mstrRow["REQ_TYPE"].ToString();
tmkReqInfo.previewYN = mstrRow["PREVIEW_REQ"].ToString();
tmkReqInfo.approvedReq = mstrRow["APPROVE_REQ"].ToString();
//// BTF_FAX_SEND_DTL ////
DataRow[] dtlRows = dtDtl.Select(String.Format("FAX_ID={0}", tmkReqInfo.faxId));
foreach (DataRow dtlRow in dtlRows)
{
SEND_REQUEST_DTL_TMK tmkDtlReqInfo = new SEND_REQUEST_DTL_TMK();
tmkDtlReqInfo.faxId = (decimal)dtlRow["FAX_ID"];
tmkDtlReqInfo.faxDtlId = (decimal)dtlRow["SEQ"];
tmkDtlReqInfo.strStateEach = dtlRow["STATE_EACH"].ToString();
tmkDtlReqInfo.strFaxNo = dtlRow["FAX_NO"].ToString();
tmkDtlReqInfo.strRecipientName = dtlRow["RECIPIENT_NAME"].ToString();
tmkDtlReqInfo.strTiffPath = dtlRow["TIF_FILE"].ToString();
tmkDtlReqInfo.strProcessFetchEach = dtlRow["PROCESS_FETCH_EACH"].ToString();
//dcvReq.m_lstSendRequestDetails.Add(dtlReq);
tmkReqInfo.m_lstTmkSendRequestDtlInfos.Add(tmkDtlReqInfo);
}
p_lstTmkSendReqInfos.Add(tmkReqInfo);
}
ret = RESULT.SUCCESS;
}
}
catch (Exception ex)
{
ExceptionMsg(ex, "PROCEDURE : " + strProcedureName);
ret = RESULT.F_SYSTEM_ERROR;
}
Close();
return(ret);
}
}
private RESULT ParseEmailDocument(POP3_Parsing p_parseMail,
ref DbModule.SendRequestMasterInfo p_reqInfo_mstr,
ref DbModule.SendRequestDetailInfo p_reqInfo_dtl,
ref DbModule.SEND_REQ_SITE p_reqInfo_site,
ref List <DbModule.SendRequestDocInfo> p_reqInfo_doc_List,
ref P_TYPE p_destProcessType)
{
p_reqInfo_mstr = new DbModule.SendRequestMasterInfo(m_ThreadName);
p_reqInfo_dtl = new DbModule.SendRequestDetailInfo();
p_reqInfo_site = new DbModule.SEND_REQ_SITE();
p_reqInfo_doc_List = new List <DbModule.SendRequestDocInfo>();
try
{
/// 첨부파일 Boundary 추출
List <POP3_BoundaryInfo> attachFileList = GetAttachFileList(p_parseMail.BoundaryInfoList);
if (attachFileList.Count == 0)
{
return(RESULT.F_FILE_CNT_ZERO);
}
/// 메일 제목 분석
if (ParseEmailTitle(p_parseMail.Subject, ref p_reqInfo_mstr, ref p_reqInfo_dtl) == false)
{
AppLog.Write(LOG_LEVEL.ERR, string.Format("Email 제목이 형식에 맞지 않습니다. ({0} / {1})", Config.EMAIL_TITLE_FORMAT, p_parseMail.Subject));
//continue;
return(RESULT.F_PARSE_ERROR);
}
/// REQ_TYPE, Dest Process Type 결정
SetReqType(attachFileList, ref p_reqInfo_mstr, ref p_reqInfo_dtl, ref p_destProcessType);
/// PSC 는 tif 1개로 DCV, TPC 필요없음.
if (p_destProcessType == P_TYPE.PSC)
{
POP3_BoundaryInfo bi = attachFileList[0];
/// Email AttachFile -> Local File
string filePath = p_parseMail.ConvertBase64ToFile(m_DownloadEmailAttachFileLocalPath, bi);
if (filePath.Length == 0)
{
return(RESULT.F_FILE_NOT_EXIST);
}
/// File name is must unique. (File Rename)
FileInfo fi = new FileInfo(filePath);
do
{
fi.MoveTo(string.Format(@"{0}\{1}_{2}.{3}", fi.Directory, bi.RepresentationFilenameOnly, DateTime.Now.ToString("yyyyMMddHHmmss.fffffff"), bi.RepresentationFilenameExtension));
//} while (File.Exists(Path.Combine(m_AoxInputDocPath, fi.Name)));
} while (File.Exists(Path.Combine(Config.FINISHED_TIF_PATH, m_RelativePath, fi.Name)));
/// Local -> Destination
//fi.MoveTo(Path.Combine(m_AoxInputDocPath, fi.Name));
fi.MoveTo(Path.Combine(Config.FINISHED_TIF_PATH, m_RelativePath, fi.Name));
//p_reqInfo_dtl.TIF_FILE = Path.Combine(m_RelativePath, attachFileList[0].RepresentationFilename);
p_reqInfo_dtl.TIF_FILE = Path.Combine(m_RelativePath, fi.Name);
}
else
{
/// 첨부파일 AOX_INPUT_DOC_PATH 로 이동
foreach (POP3_BoundaryInfo bi in attachFileList)
{
/// Email AttachFile -> Local File
string filePath = p_parseMail.ConvertBase64ToFile(m_DownloadEmailAttachFileLocalPath, bi);
if (filePath.Length == 0)
{
continue;
}
/// File name is must unique.
FileInfo fi = new FileInfo(filePath);
do
{
fi.MoveTo(string.Format(@"{0}\{1}_{2}.{3}", fi.Directory, bi.RepresentationFilenameOnly, DateTime.Now.ToString("yyyyMMddHHmmss.fffffff"), bi.RepresentationFilenameExtension));
} while (File.Exists(Path.Combine(m_AoxInputDocPath, fi.Name)));
/// Local -> Destination
fi.MoveTo(Path.Combine(m_AoxInputDocPath, fi.Name));
/// DOC info
DbModule.SendRequestDocInfo doc = new DbModule.SendRequestDocInfo();
doc.DOC_PATH = Config.AOX_INPUT_DOCS_PATH;
doc.strDocFile = fi.Name.Substring(0, fi.Name.LastIndexOf("."));
doc.strDocExt = fi.Name.Substring(fi.Name.LastIndexOf(".") + 1);
p_reqInfo_doc_List.Add(doc);
}
}
AppLog.Write(LOG_LEVEL.MSG, string.Format("[ Subject: {0} ] 메일을 분석 완료하였습니다.", p_parseMail.Subject));
return(RESULT.SUCCESS);
}
catch (Exception ex)
{
AppLog.ExceptionLog(ex, "");
return(RESULT.F_PARSE_ERROR);
}
}
