/// <summary>
/// To Process request and create csv and xml files.
/// </summary>
/// <param name="operationContext">Current OperationContext</param>
/// <returns></returns>
private ProcessData ProcessRequestAndCreateFiles(OperationContext operationContext, XCBL_User xCblServiceUser)
{
try
{
ProcessData processData = ValidateScheduleShippingXmlDocument(operationContext.RequestContext, xCblServiceUser);
if (processData != null && !string.IsNullOrEmpty(processData.ScheduleID) &&
!string.IsNullOrEmpty(processData.OrderNumber) &&
!string.IsNullOrEmpty(processData.CsvFileName))
{
MeridianSystemLibrary.LogTransaction(xCblServiceUser.WebUsername, xCblServiceUser.FtpUsername, "ProcessRequestAndCreateFiles", "01.03", string.Format("Success - Parsed requested xml for CSV file {0}", processData.ScheduleID), "Shipping Schedule Process", processData.CsvFileName, processData.ScheduleID, processData.OrderNumber, processData.XmlDocument, "Success");
if (UsePBSServiceDataAndUpdateFlags(processData))
{
return(processData);
}
else
{
return(null);
}
}
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(xCblServiceUser.WebUsername, xCblServiceUser.FtpUsername, "ValidateScheduleShippingXmlDocument", "03.02", "Error - Incorrect request ", string.Format("Exception - Invalid request xml {0}", ex.Message), "No file Name", "No Schedule Id", "No Order Number", null, "Error 03.02 - Invalid request xml");
}
return(new ProcessData());
}
/// <summary>
/// To Delete created file
/// </summary>
/// <param name="filePath">File Path</param>
/// <param name="processData">Process Data</param>
/// <returns></returns>
internal static bool DeleteFile(string filePath, MeridianResult meridianResult = null)
{
bool result = false;
if (meridianResult == null)
{
meridianResult = new MeridianResult();
}
try
{
if (File.Exists(filePath))
{
string fileName = Path.GetFileName(filePath);
string ext = Path.GetExtension(filePath);
File.Delete(filePath);
result = true;
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "DeleteFile", "01.07", string.Format("Success - Deleted CSV file {0} after ftp upload: {0}", fileName), string.Format("Deleted CSV file: {0}", fileName), fileName, meridianResult.UniqueID, meridianResult.OrderNumber, null, "Success");
}
result = true;
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "DeleteFile", "03.09", "Error - Delete CSV File", string.Format("Error - While deleting local CSV file: {0} with error {1}", meridianResult.FileName, ex.Message), meridianResult.FileName, meridianResult.UniqueID, meridianResult.OrderNumber, null, "Error 03.09 - Delete local CSV");
result = false;
}
return(result);
}
private void PbsFrequencyTimer_Elapsed(object sender, ElapsedEventArgs e)
{
MeridianSystemLibrary.LogTransaction(null, null, "PbsFrequencyTimer_Elapsed", "01.09", "Success - inside PbsFrequencyTimer_Elapsed", "Success - inside PbsFrequencyTimer_Elapsed", null, null, null, null, "Success - inside PbsFrequencyTimer_Elapsed");
var dateNow = DateTime.Now;
var startTime = MeridianGlobalConstants.PBS_QUERY_START_TIME;
var startTimeParts = startTime.Split(new char[1] {
':'
});
var startDateTime = new DateTime(dateNow.Year, dateNow.Month, dateNow.Day, int.Parse(startTimeParts[0]), int.Parse(startTimeParts[1]), 00);
var endTime = MeridianGlobalConstants.PBS_QUERY_END_TIME;
endTime = !string.IsNullOrWhiteSpace(endTime) ? endTime : MeridianGlobalConstants.DEFAULT_PBS_QUERY_END_TIME;
var endTimeParts = endTime.Split(new char[1] {
':'
});
var endDateTime = new DateTime(dateNow.Year, dateNow.Month, dateNow.Day, int.Parse(endTimeParts[0]), int.Parse(endTimeParts[1]), 00);
if ((DateTime.Now >= startDateTime) && (DateTime.Now <= endDateTime))
{
GetAllOrder();
}
else
{
pbsFrequencyTimer.Stop();
pbsFrequencyTimer.Interval = TimeSpan.FromMinutes(MeridianGlobalConstants.DEFAULT_PBS_FREQUENCY_TIMER_INTERVAL_IN_MINUTES).TotalMilliseconds;
pbsFrequencyTimer.Start();
}
}
/// <summary>
/// To return processed data i.e. XElement
/// </summary>
/// <param name="asyncResult"> object of IAsyncResult which will hold the result of current processing</param>
public XElement EndShippingScheduleResponse(IAsyncResult asyncResult)
{
var meridianAsyncResult = asyncResult as MeridianAsyncResult;
meridianAsyncResult.AsyncWait.WaitOne();
if (!meridianAsyncResult.Result.Status.Equals(MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_FAILURE, StringComparison.OrdinalIgnoreCase))
meridianAsyncResult.Result.Status = SendFileToFTP(meridianAsyncResult.Result).GetAwaiter().GetResult() ? MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_SUCCESS : MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_FAILURE;
return XElement.Parse(MeridianSystemLibrary.GetMeridian_Status(meridianAsyncResult.Result.Status, meridianAsyncResult.Result.UniqueID, meridianAsyncResult.Result.IsSchedule));
}
public XElement EndOrderRequest(IAsyncResult result)
{
var meridianAsyncResult = result as MeridianAsyncResult;
meridianAsyncResult.AsyncWait.WaitOne();
var response = XElement.Parse(MeridianSystemLibrary.GetMeridian_StatusForOrderRequest(meridianAsyncResult.Result.Status, meridianAsyncResult.Result.UniqueID, meridianAsyncResult.Result.ResultObject, meridianAsyncResult.Result.IsSchedule));
return(response);
}
/// <summary>
/// This function will authenticate the User with Username and Password
/// </summary>
/// <param name="messageHeaders">SOAP MessageHeaders </param>
/// <param name="messageHeaderInfo">MessageHeaderInfo - Contains the Soap Credential Header</param>
/// <param name="objXCBLUser">Object - Holds the user related information</param>
/// <returns></returns>
private static XCBL_User Meridian_AuthenticateUser(MessageHeaders messageHeaders, MessageHeaderInfo messageHeaderInfo, int index)
{
try
{
string username = string.Empty;
string password = string.Empty;
string hashkey = string.Empty;
// Retrieve the Credential header information
// If a separate namespace is needed for the Credentials tag use the global const CREDENTIAL_NAMESPACE that is commented below
if (messageHeaderInfo.Name == MeridianGlobalConstants.CREDENTIAL_HEADER)// && h.Namespace == MeridianGlobalConstants.CREDENTIAL_NAMESPACE)
{
// read the value of that header
XmlReader xr = messageHeaders.GetReaderAtHeader(index);
while (xr.Read())
{
if (xr.IsStartElement())
{
if (xr.Name == MeridianGlobalConstants.CREDENTIAL_USERNAME)
{
if (xr.Read())
{
username = xr.Value;
}
}
else if (xr.Name == MeridianGlobalConstants.CREDENTIAL_PASSWORD)
{
if (xr.Read())
{
password = xr.Value;
}
}
else if (xr.Name == MeridianGlobalConstants.CREDENTIAL_HASHKEY)
{
if (xr.Read())
{
hashkey = xr.Value;
}
}
}
}
}
if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password) && !string.IsNullOrEmpty(hashkey))
{
username = Encryption.Decrypt(username, hashkey);
password = Encryption.Decrypt(password, hashkey);
return(MeridianSystemLibrary.sysGetAuthenticationByUsernameAndPassword(username, password));
}
return(null);
}
catch (Exception ex)
{
return(null);
}
}
/// <summary>
/// To send Shipping Schedule Response to AWC.
/// </summary>
/// <param name="filePath">File Path </param>
/// <param name="content">Content want to write</param>
/// <param name="processData">Process Data</param>
/// <returns></returns>
internal async static void SendShippingScheduleResponse1(MeridianResult meridianResult, string responseTypeCoded = null)
{
try
{
string shippingScheduleRequestId = null;
responseTypeCoded = !string.IsNullOrWhiteSpace(responseTypeCoded) ? responseTypeCoded : (meridianResult.Approve01.Equals(MeridianGlobalConstants.XCBL_YES_FLAG) ||
meridianResult.Approve02.Equals(MeridianGlobalConstants.XCBL_YES_FLAG) ||
meridianResult.Approve03.Equals(MeridianGlobalConstants.XCBL_YES_FLAG) ||
meridianResult.Approve04.Equals(MeridianGlobalConstants.XCBL_YES_FLAG) ||
meridianResult.Approve05.Equals(MeridianGlobalConstants.XCBL_YES_FLAG)) ?
MeridianGlobalConstants.XCBL_RESPONSE_TYPE_CODED_SHIPPING_SCHEDULE_RESPONSE_ACCEPTED :
meridianResult.Rejected01.Equals(MeridianGlobalConstants.XCBL_YES_FLAG) ?
MeridianGlobalConstants.XCBL_RESPONSE_TYPE_CODED_SHIPPING_SCHEDULE_RESPONSE_REJECTED :
MeridianGlobalConstants.XCBL_RESPONSE_TYPE_CODED_SHIPPING_SCHEDULE_RESPONSE_PENDING;
var purposeCoded = MeridianGlobalConstants.XCBL_PURPOSE_CODED_SHIPPING_SCHEDULE_RESPONSE;
for (int i = 0; i < 3; i++)//Loop through 3 times if got response unsuccessful
{
bool isSuccess = false;
/*Below code to send Shipping Schedule Request to AWC*/
using (var client = new WebClient())
{
var data = CreateShippingScheduleResponse(meridianResult, responseTypeCoded, purposeCoded, ref shippingScheduleRequestId);
var requestData = Encoding.ASCII.GetBytes(data);
client.Headers.Add("Content-Type", "text/xml;charset=utf-8");
client.Headers.Add("SOAPAction", MeridianGlobalConstants.CONFIG_AWC_ACTION);
try
{
var responseData = await client.UploadDataTaskAsync(new Uri(MeridianGlobalConstants.CONFIG_AWC_ENDPOINT), requestData);
var response = Encoding.ASCII.GetString(responseData);
isSuccess = GetCurrentShippingScheduleRequestResponse(response, data, shippingScheduleRequestId, meridianResult.OrderNumber);
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "SendShippingScheduleResponse", "06.07", "Error - Send ShippingScheduleResponse Request", string.Format("Error - While sending SSR Request: {0}", ex.Message), meridianResult.FileName, meridianResult.UniqueID, meridianResult.OrderNumber, meridianResult.XmlDocument, "Error 06.07 - Send AWC SSR Request");
}
finally
{
client.Dispose();
}
}
if (isSuccess)
{
break;
}
}
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "SendShippingScheduleResponse", "06.07", "Error - Send ShippingScheduleResponse Request", string.Format("Error - While sending SSR Request: {0}", ex.Message), meridianResult.FileName, meridianResult.UniqueID, meridianResult.OrderNumber, meridianResult.XmlDocument, "Error 06.07 - Send AWC SSR Request");
}
}
/// <summary>
/// Soap Method to pass xCBL XML data to the web serivce
/// </summary>
/// <param name="ShippingScheduleResponse">XmlElement the xCBL XML data to parse</param>
/// <returns>XElement - XML Message Acknowledgement response indicating Success or Failure</returns>
public XElement ShippingScheduleResponse()
{
ProcessShippingScheduleResponse objProcess = new ProcessShippingScheduleResponse();
var meridianResult = objProcess.ProcessShippingScheduleResponseRequest(OperationContext.Current);
if (!meridianResult.Status.Equals(MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_FAILURE, StringComparison.OrdinalIgnoreCase))
{
meridianResult.Status = SendFileToFTP(meridianResult).GetAwaiter().GetResult() ? MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_SUCCESS : MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_FAILURE;
}
return(XElement.Parse(MeridianSystemLibrary.GetMeridian_Status(meridianResult.Status, meridianResult.UniqueID, meridianResult.IsSchedule)));
}
/// <summary>
/// To upload file to FTP from MeridianResult.
/// </summary>
private async Task <bool> SendFileToFTP(MeridianResult meridianResult)
{
if ((meridianResult != null) && !string.IsNullOrWhiteSpace(meridianResult.FileName))
{
try
{
FtpWebRequest ftpRequest = (FtpWebRequest)FtpWebRequest.Create(meridianResult.FtpServerInFolderPath + meridianResult.FileName);
ftpRequest.Credentials = new NetworkCredential(meridianResult.FtpUserName, meridianResult.FtpPassword);
ftpRequest.Method = WebRequestMethods.Ftp.UploadFile;
ftpRequest.UseBinary = true;
ftpRequest.KeepAlive = false;
ftpRequest.Timeout = Timeout.Infinite;
if (meridianResult.UploadFromLocalPath)
{
using (StreamReader sourceStream = new StreamReader(meridianResult.LocalFilePath + meridianResult.FileName))
meridianResult.Content = Encoding.UTF8.GetBytes(sourceStream.ReadToEnd());
}
using (Stream requestStream = await ftpRequest.GetRequestStreamAsync())
{
requestStream.Write(meridianResult.Content, 0, meridianResult.Content.Length);
requestStream.Flush();
}
using (FtpWebResponse response = (FtpWebResponse)ftpRequest.GetResponse())
if (response.StatusCode == FtpStatusCode.ClosingData)
{
var prefixToTake = meridianResult.IsSchedule ? MeridianGlobalConstants.XCBL_AWC_FILE_PREFIX : MeridianGlobalConstants.XCBL_AWC_REQUISITION_FILE_PREFIX;
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, (prefixToTake + "- Successfully completed request"), "01.06", string.Format("{0} - Successfully completed request for {1}", prefixToTake, meridianResult.UniqueID), string.Format("Uploaded CSV file: {0} on ftp server successfully for {1}", meridianResult.FileName, meridianResult.UniqueID), meridianResult.FileName, meridianResult.UniqueID, meridianResult.OrderNumber, meridianResult.XmlDocument, "Success");
if (meridianResult.IsSchedule && MeridianGlobalConstants.CONFIG_AWC_CALL_SSR_REQUEST.Equals(MeridianGlobalConstants.XCBL_YES_FLAG, StringComparison.OrdinalIgnoreCase))
{
CommonProcess.SendShippingScheduleResponse1(meridianResult);
}
return(true);
}
else
{
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "UploadFileToFtp", "03.08", "Error - While CSV uploading file - Inside TRY block", string.Format("Error - While uploading CSV file: {0} with error - Inside TRY block - ", meridianResult.FileName), meridianResult.FileName, meridianResult.UniqueID, meridianResult.OrderNumber, null, "Error 03.08 - Upload CSV to PBS");
return(false);
}
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "UploadFileToFtp", "03.08", "Error - While CSV uploading file - Inside CATCH block", string.Format("Error - While uploading CSV file: {0} with error {1} - Inside CATCH block - ", meridianResult.FileName, ex.Message), meridianResult.FileName, meridianResult.UniqueID, meridianResult.OrderNumber, null, "Error 03.08 - Upload CSV to PBS");
return(false);
}
}
return(false);
}
/// <summary>
/// To Create file if not exist and on catch safer side: if first call created file but on write got issue so deleting that file so that for next createfile call it creates again and close.
/// </summary>
/// <param name="filePath">File Path </param>
/// <param name="content">Content want to write</param>
/// <returns></returns>
internal static bool CreateLogFile(string filePath, string content)
{
try
{
DeleteFile(filePath);// Safer side
File.Create(filePath).Close();
File.WriteAllText(filePath, content);
return(true);
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(null, null, "CreateLogFile", "03.14", "Error - Create PBS Log File", string.Format("Error - While creating PBS log file with error {0}", ex.Message), filePath, null, null, null, "Error 03.14 - Create PBS Log File");
return(false);
}
}
internal static bool GetCurrentShippingScheduleRequestResponse(string strResponse, string strRequest, string uniqueId, string orderNumber)
{
var currentXmlDocument = new XmlDocument();
currentXmlDocument.LoadXml(strRequest);
if (!string.IsNullOrWhiteSpace(strResponse))
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(strResponse);
XmlNamespaceManager xmlNsManager = new XmlNamespaceManager(xmlDoc.NameTable);
xmlNsManager.AddNamespace("s", "http://schemas.xmlsoap.org/soap/envelope/");
xmlNsManager.AddNamespace("ns0", "rrn:org.xcbl:schemas/xcbl/v4_0/messagemanagement/v1_0/messagemanagement.xsd");
xmlNsManager.AddNamespace("es", "rrn:org.xcbl:schemas/xcbl/v4_0/externalschemas/externalschemas.xsd");
xmlNsManager.AddNamespace("core", "rrn:org.xcbl:schemas/xcbl/v4_0/core/core.xsd");
var acknowledgementNote = xmlDoc.GetElementsByTagName(MeridianGlobalConstants.XCBL_ACKNOWLEDGEMENT_NOTE).Item(0);
if (acknowledgementNote != null)
{
var currentStatus = acknowledgementNote.GetNodeByNameAndLogWarningTrans(xmlNsManager, MeridianGlobalConstants.XCBL_ACKNOWLEDGEMENT_SUCCESS, "05.02", new ProcessData(), uniqueId, "GetCurrentShippingScheduleRequestResponse");
if ((currentStatus != null) && (!string.IsNullOrWhiteSpace(currentStatus.InnerText)))
{
var isSuccess = currentStatus.InnerText.ReplaceSpecialCharsWithSpace().Trim().Equals(MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_SUCCESS, StringComparison.OrdinalIgnoreCase);
if (isSuccess)
{
MeridianSystemLibrary.LogTransaction(string.Empty, string.Empty, "GetCurrentShippingScheduleRequestResponse", "04.02", "Success - Shipping Schedule Request Response Successful", "Shipping Schedule Request Response", string.Empty, uniqueId, orderNumber, currentXmlDocument, "Success");
}
else
{
MeridianSystemLibrary.LogTransaction(string.Empty, string.Empty, "GetCurrentShippingScheduleRequestResponse", "05.03", "Warning - Shipping Schedule Request Response Unsuccessful", "Shipping Schedule Request Response", string.Empty, uniqueId, orderNumber, currentXmlDocument, "Warning");
}
return(isSuccess);
}
}
else
{
MeridianSystemLibrary.LogTransaction(string.Empty, string.Empty, "GetCurrentShippingScheduleRequestResponse", "05.01", "Warning - No Acknowledgement Note", "Acknowledgement note not found", string.Empty, uniqueId, orderNumber, currentXmlDocument, "Warning");
}
}
else
{
MeridianSystemLibrary.LogTransaction(string.Empty, string.Empty, "GetCurrentShippingScheduleRequestResponse", "06.03", "Error - No Response", "Response not found", string.Empty, uniqueId, orderNumber, currentXmlDocument, "Error 06.03 - No AWC SSRRequest Response");
}
return(false);
}
/// <summary>
/// To return processed data i.e. XElement
/// </summary>
/// <param name="asyncResult"> object of IAsyncResult which will hold the result of current processing</param>
public XElement EndRequisition(IAsyncResult asyncResult)
{
var meridianAsyncResult = asyncResult as MeridianAsyncResult;
meridianAsyncResult.AsyncWait.WaitOne();
if (!meridianAsyncResult.Result.Status.Equals(MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_FAILURE, StringComparison.OrdinalIgnoreCase))
{
if (MeridianGlobalConstants.CONFIG_AWC_REQUISITION_TEST)
{
meridianAsyncResult.Result.Status = MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_SUCCESS;
}
else
{
meridianAsyncResult.Result.Status = SendFileToFTP(meridianAsyncResult.Result).GetAwaiter().GetResult() ? MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_SUCCESS : MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_FAILURE;
}
}
return(XElement.Parse(MeridianSystemLibrary.GetMeridian_Status(meridianAsyncResult.Result.Status, meridianAsyncResult.Result.UniqueID, meridianAsyncResult.Result.IsSchedule)));
}
/// <summary>
/// To Create file if not exist and on catch safer side: if first call created file but on write got issue so deleting that file so that for next createfile call it creates again and close.
/// </summary>
/// <param name="filePath">File Path </param>
/// <param name="content">Content want to write</param>
/// <param name="processData">Process Data</param>
/// <returns></returns>
internal static bool CreateFile(string content, MeridianResult meridianResult)
{
try
{
var filePath = meridianResult.LocalFilePath + meridianResult.FileName;
string fileName = Path.GetFileName(filePath);
string ext = Path.GetExtension(filePath);
DeleteFile(filePath, meridianResult);// Safer side
File.Create(filePath).Close();
File.WriteAllText(filePath, content);
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "CreateFile", "01.04", "Success - Created CSV File", "CSV File Created", meridianResult.FileName, meridianResult.UniqueID, meridianResult.OrderNumber, null, "Success");
return(true);
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "CreateFile", "03.12", "Error - Create CSV File", string.Format("Error - While creating local CSV file: {0} with error {1}", meridianResult.FileName, ex.Message), meridianResult.FileName, meridianResult.UniqueID, meridianResult.OrderNumber, null, "Error 03.12 - Create local CSV");
return(false);
}
}
/// <summary>
/// Method to pass xCBL XML data to the web serivce
/// </summary>
/// <param name="currentOperationContext">Operation context inside this XmlElement the xCBL XML data to parse</param>
/// <returns>XElement - XML Message Acknowledgement response indicating Success or Failure</returns>
internal MeridianResult ProcessShippingScheduleResponseRequest(OperationContext currentOperationContext)
{
_meridianResult = new MeridianResult();
_meridianResult.Status = MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_SUCCESS;
XCBL_User xCblServiceUser = new XCBL_User();
MeridianSystemLibrary.LogTransaction("No WebUser", "No FTPUser", "ProcessShippingScheduleResponseDocument", "01.01", "Success - New SOAP Request Received", "Shipping Schedule Response Process", "No FileName", "No Schedule ID", "No Order Number", null, "Success");
if (CommonProcess.IsAuthenticatedRequest(currentOperationContext, ref xCblServiceUser))
{
MeridianSystemLibrary.LogTransaction(xCblServiceUser.WebUsername, xCblServiceUser.FtpUsername, "IsAuthenticatedRequest", "01.02", "Success - Authenticated request", "Shipping Schedule Response Process", "No FileName", "No Schedule ID", "No Order Number", null, "Success");
ProcessData processData = ProcessRequestAndCreateFiles(currentOperationContext, xCblServiceUser);
if (processData == null || string.IsNullOrEmpty(processData.ScheduleResponseID) || string.IsNullOrEmpty(processData.OrderNumber))
{
_meridianResult.Status = MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_FAILURE;
}
else
{
processData.FtpUserName = xCblServiceUser.FtpUsername;
processData.FtpPassword = xCblServiceUser.FtpPassword;
processData.FtpServerInFolderPath = xCblServiceUser.FtpServerInFolderPath;
processData.FtpServerOutFolderPath = xCblServiceUser.FtpServerOutFolderPath;
processData.LocalFilePath = xCblServiceUser.LocalFilePath;
_meridianResult.WebUserName = xCblServiceUser.WebUsername;
_meridianResult.WebPassword = xCblServiceUser.WebPassword;
_meridianResult.WebHashKey = xCblServiceUser.Hashkey;
if (!CreateLocalCsvFile(processData))
{
_meridianResult.Status = MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_FAILURE;
}
_meridianResult.UniqueID = processData.ScheduleResponseID;
return(_meridianResult);
}
}
else
{
_meridianResult.Status = MeridianGlobalConstants.MESSAGE_ACKNOWLEDGEMENT_FAILURE;
MeridianSystemLibrary.LogTransaction("No WebUser", "No FTPUser", "IsAuthenticatedRequest", "03.01", "Error - New SOAP Request not authenticated", "UnAuthenticated Request", "No FileName", "No Schedule ID", "No Order Number", null, "Error 03.01 - Incorrect Credential");
}
return(_meridianResult);
}
/// <summary>
/// To validate the request and call correct class method
/// </summary>
/// <param name="operationContext"> CurrentOperationContext </param>
internal static bool IsShippingScheduleRequest(OperationContext operationContext)
{
try
{
var requestMessage = operationContext.RequestContext.RequestMessage.ToString().ReplaceSpecialCharsWithSpace(false);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(requestMessage);
XmlNamespaceManager xmlNsManager = new XmlNamespaceManager(xmlDoc.NameTable);
xmlNsManager.AddNamespace("default", "rrn:org.xcbl:schemas/xcbl/v4_0/materialsmanagement/v1_0/materialsmanagement.xsd");
xmlNsManager.AddNamespace("core", "rrn:org.xcbl:schemas/xcbl/v4_0/core/core.xsd");
XmlNodeList shippingElement = xmlDoc.GetElementsByTagName(MeridianGlobalConstants.XCBL_SHIPPING_SCHEDULE_HEADER);
return(shippingElement != null && (shippingElement.Count > 0));
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction("No WebUser", "No FTPUser", "IsShippingScheduleRequest", "03.15", "Exception - in IsShippingScheduleRequest Method", string.Format("Error - {0}", ex.Message), "No FileName", "No Requisition ID", "No Order Number", null, "Error 03.15 - Check IsShippingScheduleRequest");
return(true);
}
}
/// <summary>
/// To authenticate request whether it has valid credential to proceed
/// </summary>
/// <param name="xCblServiceUser">Service User</param>
/// <param name="operationContext">Current OperationContext</param>
/// <returns></returns>
internal static bool IsAuthenticatedRequest(OperationContext operationContext, ref XCBL_User xCblServiceUser)
{
try
{
// If a separate namespace is needed for the Credentials tag use the global const CREDENTIAL_NAMESPACE that is commented below
int index = operationContext.IncomingMessageHeaders.FindHeader("Credentials", "");
// Retrieve the first soap headers, this should be the Credentials tag
MessageHeaderInfo messageHeaderInfo = operationContext.IncomingMessageHeaders[index];
xCblServiceUser = Meridian_AuthenticateUser(operationContext.IncomingMessageHeaders, messageHeaderInfo, index);
if (xCblServiceUser == null || string.IsNullOrEmpty(xCblServiceUser.WebUsername) || string.IsNullOrEmpty(xCblServiceUser.FtpUsername))
{
MeridianSystemLibrary.LogTransaction("No WebUser", "No FTPUser", "IsAuthenticatedRequest", "03.01", "Error - New SOAP Request not authenticated", "UnAuthenticated Request", "No FileName", "No Schedule ID", "No Order Number", null, "Error 03.01 - Incorrect Credentials");
return(false);
}
return(true);
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction("No WebUser", "No FTPUser", "IsAuthenticatedRequest", "03.01", "Error - New SOAP Request not authenticated", "UnAuthenticated Request", "No FileName", "No Schedule ID", "No Order Number", null, "Error 03.01 - Incorrect Credentials");
return(false);
}
}
/// <summary>
/// To get List of contacts
/// </summary>
/// <param name="xmlNsManager"> XmlNamespaceManager </param>
/// <param name="element">Main xml node from requested data </param>
/// <param name="processData">Process data</param>
private void GetListOfContactNumber(XmlNamespaceManager xmlNsManager, XmlNode element, ProcessData processData)
{
var lisOfContactNumber = element.GetNodeByNameAndLogWarningTrans(xmlNsManager, MeridianGlobalConstants.XCBL_LIST_OF_CONTACT_NUMBERS, "13", processData, processData.ScheduleResponseID, "GetListOfContactNumber");
if (lisOfContactNumber != null && lisOfContactNumber.ChildNodes != null)
{
XmlNodeList xnlContactNames = lisOfContactNumber.ChildNodes;
for (int iContactNameIndex = 0; iContactNameIndex < xnlContactNames.Count; iContactNameIndex++)
{
XmlNodeList xnlContactValues = xnlContactNames[iContactNameIndex].ChildNodes;
for (int iContactValuesIndex = 0; iContactValuesIndex < xnlContactValues.Count; iContactValuesIndex++)
{
if (xnlContactValues[iContactValuesIndex].Name.Contains(MeridianGlobalConstants.XCBL_CONTACT_VALUE))
{
processData.ShippingScheduleResponse.SetContactNumbers(xnlContactValues[iContactValuesIndex].InnerText.ReplaceSpecialCharsWithSpace(), iContactNameIndex);
}
}
}
}
else if (lisOfContactNumber.ChildNodes == null)
{
MeridianSystemLibrary.LogTransaction(processData.WebUserName, processData.FtpUserName, "GetListOfContactNumber", "14", "Warning - The Contact Number Not Found.", "Warning - Contact Number", processData.CsvFileName, processData.ScheduleResponseID, processData.OrderNumber, null, "Warning 14 - Contact Name Not Found");
}
}
/// <summary>
/// To create CSV file
/// </summary>
/// <param name="processData">Process data</param>
/// <returns></returns>
private bool CreateLocalCsvFile(ProcessData processData)
{
bool result = false;
try
{
if (processData != null && !string.IsNullOrEmpty(processData.ScheduleResponseID) &&
!string.IsNullOrEmpty(processData.OrderNumber) &&
!string.IsNullOrEmpty(processData.CsvFileName))
{
var record = string.Format(MeridianGlobalConstants.SHIPPING_SCHEDULE_RESPONSE_CSV_HEADER_NAMES_FORMAT,
processData.ShippingScheduleResponse.ScheduleResponseID, processData.ShippingScheduleResponse.ScheduleResponseIssueDate, processData.ShippingScheduleResponse.ScheduleResponseOrderNumber,
processData.ShippingScheduleResponse.ScheduleResponsePurposeCoded, processData.ShippingScheduleResponse.ScheduleResponseTypeCoded, "",
processData.ShippingScheduleResponse.ScheduleID, processData.ShippingScheduleResponse.ScheduleIssuedDate, processData.ShippingScheduleResponse.OrderNumber, processData.ShippingScheduleResponse.SequenceNumber,
processData.ShippingScheduleResponse.Other_FirstStop, processData.ShippingScheduleResponse.Other_Before7, processData.ShippingScheduleResponse.Other_Before9, processData.ShippingScheduleResponse.Other_Before12, processData.ShippingScheduleResponse.Other_SameDay, processData.ShippingScheduleResponse.Other_OwnerOccupied, processData.ShippingScheduleResponse.Other_7, processData.ShippingScheduleResponse.Other_8, processData.ShippingScheduleResponse.Other_9, processData.ShippingScheduleResponse.Other_10,
processData.ShippingScheduleResponse.PurposeCoded, processData.ShippingScheduleResponse.ScheduleType, processData.ShippingScheduleResponse.AgencyCoded, processData.ShippingScheduleResponse.Name1, processData.ShippingScheduleResponse.Street, processData.ShippingScheduleResponse.StreetSupplement1, processData.ShippingScheduleResponse.PostalCode, processData.ShippingScheduleResponse.City, processData.ShippingScheduleResponse.RegionCoded,
processData.ShippingScheduleResponse.ContactName, processData.ShippingScheduleResponse.ContactNumber_1, processData.ShippingScheduleResponse.ContactNumber_2, processData.ShippingScheduleResponse.ContactNumber_3, processData.ShippingScheduleResponse.ContactNumber_4, processData.ShippingScheduleResponse.ContactNumber_5, processData.ShippingScheduleResponse.ContactNumber_6,
processData.ShippingScheduleResponse.ShippingInstruction, processData.ShippingScheduleResponse.GPSSystem, processData.ShippingScheduleResponse.Latitude.ToString(), processData.ShippingScheduleResponse.Longitude.ToString(), processData.ShippingScheduleResponse.LocationID, processData.ShippingScheduleResponse.EstimatedArrivalDate, processData.ShippingScheduleResponse.OrderType,
processData.ShippingScheduleResponse.ScheduleResponseOrderNumber.ExtractNumericOrderNumber());
StringBuilder strBuilder = new StringBuilder(MeridianGlobalConstants.SHIPPING_SCHEDULE_RESPONSE_CSV_HEADER_NAMES);
strBuilder.AppendLine();
strBuilder.AppendLine(record);
string csvContent = strBuilder.ToString();
_meridianResult.FtpUserName = processData.FtpUserName;
_meridianResult.FtpPassword = processData.FtpPassword;
_meridianResult.FtpServerInFolderPath = processData.FtpServerInFolderPath;
_meridianResult.FtpServerOutFolderPath = processData.FtpServerOutFolderPath;
_meridianResult.LocalFilePath = processData.LocalFilePath;
_meridianResult.WebUserName = processData.WebUserName;
_meridianResult.UniqueID = processData.ScheduleResponseID;
_meridianResult.OrderNumber = processData.OrderNumber;
_meridianResult.FileName = processData.CsvFileName;
if (MeridianGlobalConstants.CONFIG_CREATE_LOCAL_CSV == MeridianGlobalConstants.SHOULD_CREATE_LOCAL_FILE)
{
_meridianResult.UploadFromLocalPath = true;
return(CommonProcess.CreateFile(csvContent, _meridianResult));
}
else
{
byte[] content = Encoding.UTF8.GetBytes(csvContent);
int length = content.Length;
if (!string.IsNullOrEmpty(processData.CsvFileName) && length > 40)
{
_meridianResult.Content = content;
result = true;
}
else
{
MeridianSystemLibrary.LogTransaction(processData.WebUserName, processData.FtpUserName, "CreateLocalCsvFile", "03.06", ("Error - Creating CSV File because of Stream " + length), string.Format("Error - Creating CSV File {0} with error of Stream", processData.CsvFileName), processData.CsvFileName, processData.ScheduleResponseID, processData.OrderNumber, processData.XmlDocument, "Error 03.06 - Create CSV File");
}
}
}
else
{
MeridianSystemLibrary.LogTransaction(processData.WebUserName, processData.FtpUserName, "CreateLocalCsvFile", "03.06", "Error - Creating CSV File because of Process DATA", string.Format("Error - Creating CSV File {0} with error of Process DATA", processData.CsvFileName), processData.CsvFileName, processData.ScheduleResponseID, processData.OrderNumber, processData.XmlDocument, "Error 03.06 - Create CSV File");
}
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(processData.WebUserName, processData.FtpUserName, "CreateLocalCsvFile", "03.06", "Error - Creating CSV File", string.Format("Error - Creating CSV File {0} with error {1}", processData.CsvFileName, ex.Message), processData.CsvFileName, processData.ScheduleResponseID, processData.OrderNumber, processData.XmlDocument, "Error 03.06 - Create CSV File");
}
return(result);
}
private void GetAllOrder()
{
IsProcessing = true;
MeridianSystemLibrary.LogTransaction(null, null, "GetAllOrder", "01.10", "Success - inside GetAllOrder", "Success - inside GetAllOrder", null, null, null, null, "Success - inside GetAllOrder");
var allLatestPBSOrders = new Dictionary <string, PBSData>();
pbsFrequencyTimer.Stop();
pbsFrequencyTimer.Interval = TimeSpan.FromMinutes(MeridianGlobalConstants.PBS_QUERY_FREQUENCY).TotalMilliseconds;
pbsFrequencyTimer.Start();
string fileNameFormat = DateTime.Now.ToString(MeridianGlobalConstants.XCBL_FILE_DATETIME_FORMAT);
using (HttpClient client = new HttpClient())
{
var sqlQuery = string.Format(MeridianGlobalConstants.PBS_WEB_SERVICE, MeridianGlobalConstants.PBS_WEB_SERVICE_QUERY, MeridianGlobalConstants.CONFIG_PBS_WEB_SERVICE_USER_NAME,
MeridianGlobalConstants.CONFIG_PBS_WEB_SERVICE_PASSWORD);
var res = client.GetAsync(sqlQuery).Result;
var resultString = client.GetStringAsync(MeridianGlobalConstants.PBS_OUTPUT_FILE).Result;
if (MeridianGlobalConstants.PBS_ENABLE_CACHE_LOG == MeridianGlobalConstants.XCBL_YES_FLAG)
{
CommonProcess.CreateLogFile(string.Format("{0}\\PBS{1}voc.txt", MeridianGlobalConstants.PBS_CACHE_LOG_LOCATION, fileNameFormat), resultString);
}
if (!string.IsNullOrWhiteSpace(resultString))
{
var lines = resultString.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
if (lines.Count() > 1)
{
for (int i = 1; i < lines.Length; i++)
{
if (!string.IsNullOrWhiteSpace(lines[i]))
{
var values = lines[i].Split(',');
if (values.Length > 29)
{
DateTimeOffset orderDate;
if (DateTimeOffset.TryParse(values[4], out orderDate))
{
PBSData pbsData = new PBSData();
pbsData.DeliveryDate = values[1];
pbsData.ShipmentDate = values[2];
pbsData.IsScheduled = values[3];
pbsData.OrderNumber = values[10].Trim();
pbsData.DestinationName = values[25];
pbsData.DestinationStreet = values[26];
pbsData.DestinationStreetSupplyment1 = values[27];
pbsData.DestinationCity = values[28];
pbsData.DestinationRegionCoded = string.Format(MeridianGlobalConstants.XCBL_US_CODE + values[29]);
pbsData.DestinationPostalCode = values[30];
if (!allLatestPBSOrders.ContainsKey(pbsData.OrderNumber))
{
allLatestPBSOrders.Add(pbsData.OrderNumber.Trim(), pbsData);
}
}
}
else
{
MeridianSystemLibrary.LogTransaction(null, null, "GetAllOrder", "02.25", "Warning - Values lenght less then 29", "Warning - Values lenght less then 29 from PBS WebService",
null, null, null, null, "Warning 02.25 : Values lenght less then 29");
}
}
}
}
else
{
MeridianSystemLibrary.LogTransaction(null, null, "GetAllOrder", "02.26", "Warning - PBS File Lines Count < 2", "Warning - PBS File Lines Count < 2 from PBS WebService", null,
null, null, null, "Warning 02.26 : PBS File Lines Count < 2");
}
}
else
{
MeridianSystemLibrary.LogTransaction(null, null, "GetAllOrder", "02.27", "Warning - Empty PBS text file", "Warning - Empty PBS text file from PBS WebService",
null, null, null, null, "Warning 02.27 : Empty Text File");
}
}
if (MeridianGlobalConstants.PBS_ENABLE_CACHE_LOG == MeridianGlobalConstants.XCBL_YES_FLAG)
{
StringBuilder strBuilder = new StringBuilder(MeridianGlobalConstants.PBS_CSV_HEADERS);
strBuilder.AppendLine();
foreach (var item in allLatestPBSOrders)
{
strBuilder.AppendLine(string.Format(MeridianGlobalConstants.PBS_CSV_HEADER_NAME_FORMAT,
item.Value.DeliveryDate, item.Value.ShipmentDate, item.Value.IsScheduled,
item.Value.OrderNumber, item.Value.DestinationName, item.Value.DestinationStreet,
item.Value.DestinationStreetSupplyment1, item.Value.DestinationCity, item.Value.DestinationRegionCoded,
item.Value.DestinationPostalCode));
}
CommonProcess.CreateLogFile(string.Format("{0}\\XCBL{1}PBSCachedOrders.csv", MeridianGlobalConstants.PBS_CACHE_LOG_LOCATION, fileNameFormat), strBuilder.ToString());
}
AllPBSOrder = allLatestPBSOrders;
IsProcessing = false;
}
/// <summary>
/// To Parse sent SOAP XML and make list of Process data
/// </summary>
/// <param name="requestContext"> Current OperationContext's RequestContext</param>
/// <param name="xCblServiceUser">Service User</param>
/// <returns>List of process data</returns>
private ProcessData ValidateScheduleShippingResponseXmlDocument(RequestContext requestContext, XCBL_User xCblServiceUser)
{
var requestMessage = requestContext.RequestMessage.ToString().ReplaceSpecialCharsWithSpace(false);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(requestMessage);
XmlNamespaceManager xmlNsManager = new XmlNamespaceManager(xmlDoc.NameTable);
xmlNsManager.AddNamespace("default", "rrn:org.xcbl:schemas/xcbl/v4_0/materialsmanagement/v1_0/materialsmanagement.xsd");
xmlNsManager.AddNamespace("core", "rrn:org.xcbl:schemas/xcbl/v4_0/core/core.xsd");
XmlNodeList shippingElement = xmlDoc.GetElementsByTagName(MeridianGlobalConstants.XCBL_SHIPPING_SCHEDULE_RESPONSE_HEADER);
//Find the Shipping schedule response tag and getting the Inner Xml of its Node
XmlNodeList shippingScheduleResponseNode_xml = xmlDoc.GetElementsByTagName(MeridianGlobalConstants.XCBL_ShippingScheuleResponse_XML_Http); //Http Request creating this tag
if (shippingScheduleResponseNode_xml.Count == 0)
{
shippingScheduleResponseNode_xml = xmlDoc.GetElementsByTagName(MeridianGlobalConstants.XCBL_ShippingScheuleResponse_XML_Https); //Https Request creating this tag
}
if (shippingElement != null)
{
// There should only be one element in the Shipping Schedule request, but this should handle multiple ones
foreach (XmlNode element in shippingElement)
{
var processData = xCblServiceUser.GetNewProcessData();
processData.XmlDocument = xmlDoc;
_meridianResult.XmlDocument = xmlDoc;
var scheduleResponseId = element.GetNodeByNameAndLogErrorTrans(xmlNsManager, MeridianGlobalConstants.XCBL_SCHEDULE_RESPONSE_ID, "10", processData, processData.ScheduleResponseID);
var scheduleResponseIssuedDate = element.GetNodeByNameAndInnerTextLogWarningTrans(xmlNsManager, MeridianGlobalConstants.XCBL_SCHEDULE_RESPONSE_ISSUE_DATE, "21", processData, processData.ScheduleResponseID);
var scheduleResponseReference = element.GetNodeByNameAndInnerTextLogWarningTrans(xmlNsManager, MeridianGlobalConstants.XCBL_SCHEDULE_RESPONSE_REFERENCE, "22", processData, processData.ScheduleResponseID);
var scheduleResponsePurposeCoded = element.GetNodeByNameAndInnerTextLogWarningTrans(xmlNsManager, MeridianGlobalConstants.XCBL_SCHEDULE_RESPONSE_PURPOSE_CODED, "03", processData, processData.ScheduleResponseID);
var scheduleResponseResponseTypeCoded = element.GetNodeByNameAndInnerTextLogWarningTrans(xmlNsManager, MeridianGlobalConstants.XCBL_SCHEDULE_RESPONSE_RESPONSE_TYPE_CODED, "23", processData, processData.ScheduleResponseID);
if (scheduleResponseId != null && !string.IsNullOrEmpty(scheduleResponseId.InnerText))
{
processData.ScheduleResponseID = scheduleResponseId.InnerText.ReplaceSpecialCharsWithSpace();
processData.ShippingScheduleResponse.ScheduleResponseID = processData.ScheduleResponseID;
if (scheduleResponseIssuedDate != null && !string.IsNullOrEmpty(scheduleResponseIssuedDate.InnerText))
{
processData.ShippingScheduleResponse.ScheduleResponseIssueDate = scheduleResponseIssuedDate.InnerText.ReplaceSpecialCharsWithSpace();
}
if (scheduleResponseReference != null && !string.IsNullOrEmpty(scheduleResponseReference.InnerText))
{
processData.OrderNumber = scheduleResponseReference.InnerText.ReplaceSpecialCharsWithSpace();
processData.ShippingScheduleResponse.ScheduleResponseOrderNumber = processData.OrderNumber;
string formattedOrderNumber = processData.OrderNumber.ReplaceSpecialCharsWithSpace().Replace(" ", "");
string fileNameFormat = DateTime.Now.ToString(MeridianGlobalConstants.XCBL_FILE_DATETIME_FORMAT);
processData.CsvFileName = string.Concat(MeridianGlobalConstants.XCBL_AWC_FILE_PREFIX, fileNameFormat, formattedOrderNumber, MeridianGlobalConstants.XCBL_FILE_EXTENSION);
processData.XmlFileName = string.Concat(MeridianGlobalConstants.XCBL_AWC_FILE_PREFIX, fileNameFormat, formattedOrderNumber, MeridianGlobalConstants.XCBL_XML_EXTENSION);
}
else
{
MeridianSystemLibrary.LogTransaction(processData.WebUserName, processData.FtpUserName, "ValidateScheduleShippingResponseXmlDocument", "03.11", "Error - Schedule Response References XML tag missing or incorrect to get order number", "Exception - Response order number", processData.CsvFileName, processData.ScheduleResponseID, "No Order Number", processData.XmlDocument, "Error 03.14 - Seller OrderNumber not found");
}
if (scheduleResponsePurposeCoded != null && !string.IsNullOrEmpty(scheduleResponsePurposeCoded.InnerText))
{
processData.ShippingScheduleResponse.ScheduleResponsePurposeCoded = scheduleResponsePurposeCoded.InnerText.ReplaceSpecialCharsWithSpace();
}
if (scheduleResponseResponseTypeCoded != null && !string.IsNullOrEmpty(scheduleResponseResponseTypeCoded.InnerText))
{
processData.ShippingScheduleResponse.ScheduleResponseTypeCoded = scheduleResponseResponseTypeCoded.InnerText.ReplaceSpecialCharsWithSpace();
}
if (string.IsNullOrWhiteSpace(processData.ShippingScheduleResponse.ScheduleResponseID) || string.IsNullOrWhiteSpace(processData.ShippingScheduleResponse.ScheduleResponseOrderNumber))
{
break;
}
var scheduleId = element.GetNodeByNameAndLogErrorTrans(xmlNsManager, MeridianGlobalConstants.XCBL_SCHEDULE_ID, "03", processData, processData.ScheduleResponseID);
var scheduleIssuedDate = element.GetNodeByNameAndInnerTextLogWarningTrans(xmlNsManager, MeridianGlobalConstants.XCBL_SCHEDULE_ISSUED_DATE, "01", processData, processData.ScheduleResponseID);
//Schedule Header Information --start
if (scheduleId != null && !string.IsNullOrEmpty(scheduleId.InnerText))
{
processData.ShippingScheduleResponse.ScheduleID = scheduleId.InnerText.ReplaceSpecialCharsWithSpace();
if (scheduleIssuedDate != null && !string.IsNullOrEmpty(scheduleIssuedDate.InnerText))
{
processData.ShippingScheduleResponse.ScheduleIssuedDate = scheduleIssuedDate.InnerText.ReplaceSpecialCharsWithSpace();
}
XmlNode xnScheduleReferences = element.GetNodeByNameAndLogWarningTrans(xmlNsManager, MeridianGlobalConstants.XCBL_SCHEDULE_REFERENCES, "02", processData, processData.ScheduleResponseID);
if (xnScheduleReferences != null)
{
GetPurchaseOrderReference(xmlNsManager, xnScheduleReferences, processData);
}
else if (string.IsNullOrEmpty(processData.ShippingScheduleResponse.OrderNumber))
{
MeridianSystemLibrary.LogTransaction(processData.WebUserName, processData.FtpUserName, "ValidateScheduleShippingResponseXmlDocument", "03.04", "Error - Schedule References XML tag missing or incorrect to get seller order number", "Exception - Seller order number", processData.CsvFileName, processData.ScheduleResponseID, "No Order Number", processData.XmlDocument, "Error 03.04 - Seller OrderNumber not found");
}
if (string.IsNullOrEmpty(processData.ShippingScheduleResponse.ScheduleID) || string.IsNullOrEmpty(processData.ShippingScheduleResponse.OrderNumber))
{
break;
}
else
{
GetOtherScheduleReferences(xmlNsManager, xnScheduleReferences, processData);
GetPurposeScheduleTypeCodeAndParty(xmlNsManager, element, processData);
GetListOfContactNumber(xmlNsManager, element, processData);
GetListOfTransportRouting(xmlNsManager, element, processData);
return(processData);
}
}
}
}
}
else
{
MeridianSystemLibrary.LogTransaction(xCblServiceUser.WebUsername, xCblServiceUser.FtpUsername, "ValidateScheduleShippingResponseXmlDocument", "03.02", "Error - Shipping Schedule Response Header XML tag missing or incorrect", "Exception - Invalid request xml", "No file Name", "No Schedule Id", "No Order Number", xmlDoc, "Error 03.02 - Invalid request xml");
}
return(new ProcessData());
}
/// <summary>
/// To Check the PBS FTP folder and if any file available then Process it and send Shipping Schedule Response Request to AWC.
/// </summary>
/// <param name="sender">timer</param>
/// <param name="e">elasped event args</param>
private static void CheckPBSFTPFolder(object sender, ElapsedEventArgs e)
{
_pbsFtpTimer.Stop();
try
{
var currentUser = MeridianSystemLibrary.sysGetAuthenticationByUsernameAndPassword(MeridianGlobalConstants.CONFIG_USER_NAME, MeridianGlobalConstants.CONFIG_PASSWORD);
if (currentUser != null)
{
WebRequest request = WebRequest.Create(currentUser.FtpServerOutFolderPath);
request.Method = WebRequestMethods.Ftp.ListDirectory;
request.Credentials = new NetworkCredential(currentUser.FtpUsername, currentUser.FtpPassword);
request.Timeout = Timeout.Infinite;
List <string> directories = new List <string>();
using (var response = (FtpWebResponse)request.GetResponse())
{
StreamReader streamReader = new StreamReader(response.GetResponseStream());
string line = streamReader.ReadLine();
while (!string.IsNullOrEmpty(line))
{
directories.Add(line);
line = streamReader.ReadLine();
}
streamReader.Close();
}
for (int i = 0; i <= (directories.Count - 1); i++)
{
if (directories[i].Contains("."))
{
var currentFileName = directories[i].ToString();
string path = currentUser.FtpServerOutFolderPath + currentFileName;
var shouldDeleteCurrentFile = false;
try
{
using (WebClient ftpClient = new WebClient())
{
ftpClient.Credentials = new NetworkCredential(currentUser.FtpUsername, currentUser.FtpPassword);
byte[] currentFileData = ftpClient.DownloadData(path);
shouldDeleteCurrentFile = CommonProcess.SendShippingScheduleResponseRequestFromPBSFTP(currentUser, currentFileName, currentFileData);
}
if (shouldDeleteCurrentFile)
{
/*After process completion delete the file so that will not process that particular file*/
FtpWebRequest ftpRequest = (FtpWebRequest)FtpWebRequest.Create(path);
ftpRequest.Credentials = new NetworkCredential(currentUser.FtpUsername, currentUser.FtpPassword);
ftpRequest.Method = WebRequestMethods.Ftp.DeleteFile;
ftpRequest.UseBinary = true;
ftpRequest.KeepAlive = false;
ftpRequest.Timeout = Timeout.Infinite;
FtpWebResponse ftpResponse = (FtpWebResponse)ftpRequest.GetResponse();
ftpResponse.Close();
ftpRequest = null;
}
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(MeridianGlobalConstants.CONFIG_USER_NAME, string.Empty, "CheckPBSFTPFolder", "06.08", "Error - While reading FTP file - Inside CATCH block", string.Format("Error - While reading FTP file: {0} with error - Inside Catch Block", ex.Message), currentFileName, string.Empty, string.Empty, null, "Error 06.08 - Read PBS FTP folder");
}
}
}
_pbsFtpTimer.Start();
}
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(MeridianGlobalConstants.CONFIG_USER_NAME, string.Empty, "CheckPBSFTPFolder", "06.04", "Error - While checking FTP folder - Inside CATCH block", string.Format("Error - While checking FTP folder: {0} with error - Inside Catch Block", ex.Message), string.Empty, string.Empty, string.Empty, null, "Error 06.04 - Check PBS FTP folder");
_pbsFtpTimer.Start();
}
}
private bool UsePBSServiceDataAndUpdateFlags(ProcessData processData)
{
bool result = false;
try
{
string destinationName = null;
string orderNumber = null;
string destinationStreet = null;
string destinationStreetSupplement1 = null;
string destinationPostalCode = null;
string destinationCity = null;
string destinationRegionCoded = null;
string scheduledShipmentDateInString = null;
string scheduledDeliveryDateInString = null;
string isScheduled = null;
/* Expecting data to come in below sequence and updating the fields based on this only
*
* JobNo,Delivery Date,ShpDate,Scheduled,Order Date,Job Order,Job Category,Job Type,Customer,
* Company Name,Contract Number,Order Number,Origin Location,Origin Name,Origin Address,Origin Address2,
* Origin City,Origin State,Origin Zip,Origin Attention,Origin Phone,Origin Phone2,Origin Fax,
* Origin Email,Destination Location,Destination Name,Destination Address,Destination Address2,
* Destination City,Destination State,Destination Zip,Destination Attention,Destination Phone,
* Destination Phone2,Destination Email,Destination Note,Service Type,Mode,Partner Name,Driver Number,
* Driver,ApprDel,ShprNo
*
*/
var pbsQueryResult = ProcessPBSQueryResult.Instance;
var currentOrderDetails = new PBSData();
if (pbsQueryResult.AllPBSOrder.ContainsKey(processData.OrderNumber.Trim()))
{
currentOrderDetails = pbsQueryResult.AllPBSOrder[processData.OrderNumber.Trim()];
}
destinationName = currentOrderDetails.DestinationName;
orderNumber = currentOrderDetails.OrderNumber;
destinationStreet = currentOrderDetails.DestinationStreet;
destinationStreetSupplement1 = currentOrderDetails.DestinationStreetSupplyment1;
destinationPostalCode = currentOrderDetails.DestinationPostalCode;
destinationCity = currentOrderDetails.DestinationCity;
destinationRegionCoded = currentOrderDetails.DestinationRegionCoded;
scheduledShipmentDateInString = currentOrderDetails.ShipmentDate;
scheduledDeliveryDateInString = currentOrderDetails.DeliveryDate;
isScheduled = currentOrderDetails.IsScheduled;
if (!string.IsNullOrWhiteSpace(scheduledShipmentDateInString) && !string.IsNullOrWhiteSpace(orderNumber) && (processData.ShippingSchedule.OrderNumber.Trim().Equals(orderNumber.Trim(), StringComparison.OrdinalIgnoreCase)))
{
#region XCBL Data
var xcblRequestDate = DateTimeOffset.Parse(processData.ShippingSchedule.ScheduleIssuedDate).UtcDateTime;
var xcblScheduledShipDate = DateTimeOffset.Parse(processData.ShippingSchedule.ScheduleIssuedDate).UtcDateTime;
DateTime?xcblScheduledDeliveryDate = null;
if (!string.IsNullOrWhiteSpace(processData.ShippingSchedule.EstimatedArrivalDate))
{
xcblScheduledDeliveryDate = DateTimeOffset.Parse(processData.ShippingSchedule.EstimatedArrivalDate).UtcDateTime;
}
var xcblDeliveryName = processData.ShippingSchedule.Name1 ?? "";
var xcblStreet = processData.ShippingSchedule.Street ?? "";
var xcblStreetSupplement1 = processData.ShippingSchedule.StreetSupplement1 ?? "";
var xcblPostalCode = processData.ShippingSchedule.PostalCode ?? "";
var xcblCity = processData.ShippingSchedule.City ?? "";
var xcblRegionCoded = processData.ShippingSchedule.RegionCoded ?? "";
var xcblSameDay = processData.ShippingSchedule.Other_SameDay ?? "";
var xcblFirstStop = processData.ShippingSchedule.Other_FirstStop ?? "";
var xcblBefore7 = processData.ShippingSchedule.Other_Before7 ?? "";
var xcblBefore9 = processData.ShippingSchedule.Other_Before9 ?? "";
var xcblBefore12 = processData.ShippingSchedule.Other_Before12 ?? "";
var xcblOwnerOccupied = processData.ShippingSchedule.Other_OwnerOccupied ?? "";
#endregion XCBL Data
#region PBS Data
destinationName = destinationName ?? "";
destinationStreet = destinationStreet ?? "";
destinationStreetSupplement1 = destinationStreetSupplement1 ?? "";
destinationCity = destinationCity ?? "";
destinationPostalCode = processData.ShippingSchedule.PostalCode ?? "";
destinationRegionCoded = destinationRegionCoded ?? "";
isScheduled = isScheduled ?? "";
var scheduledShipmentDate = DateTimeOffset.Parse(scheduledShipmentDateInString).UtcDateTime;
var scheduledShipmentDate10AM = new DateTime(scheduledShipmentDate.Year, scheduledShipmentDate.Month, scheduledShipmentDate.Day, 10, 0, 0);
DateTime?scheduledDeliveryDate = null;
DateTime?scheduledDeliveryDate10AM = null;
if (!string.IsNullOrWhiteSpace(scheduledDeliveryDateInString))
{
scheduledDeliveryDate = DateTimeOffset.Parse(scheduledDeliveryDateInString).UtcDateTime;
}
if (!string.IsNullOrWhiteSpace(scheduledDeliveryDateInString))
{
scheduledDeliveryDate10AM = new DateTime(scheduledDeliveryDate.Value.Year, scheduledDeliveryDate.Value.Month, scheduledDeliveryDate.Value.Day, 10, 0, 0);
}
#endregion PBS Data
var currentDateTime = DateTime.UtcNow;
if (isScheduled.Trim().Equals(MeridianGlobalConstants.PBS_SCHEDULED_FALSE, StringComparison.OrdinalIgnoreCase))
{
processData.ShippingSchedule.Approve05 = _meridianResult.Approve05 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
else if ((scheduledShipmentDate >= currentDateTime) && (xcblRequestDate > scheduledShipmentDate10AM.AddDays(-2)))
{
processData.ShippingSchedule.Pending01 = _meridianResult.Pending01 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
else if ((scheduledShipmentDate < currentDateTime) && scheduledDeliveryDate10AM.HasValue && (xcblRequestDate > scheduledDeliveryDate10AM.Value.AddDays(-2)))
{
processData.ShippingSchedule.Pending02 = _meridianResult.Pending02 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
else if (xcblSameDay.Equals(MeridianGlobalConstants.XCBL_YES_FLAG, StringComparison.OrdinalIgnoreCase) ||
xcblFirstStop.Equals(MeridianGlobalConstants.XCBL_YES_FLAG, StringComparison.OrdinalIgnoreCase) ||
xcblBefore7.Equals(MeridianGlobalConstants.XCBL_YES_FLAG, StringComparison.OrdinalIgnoreCase) ||
xcblBefore9.Equals(MeridianGlobalConstants.XCBL_YES_FLAG, StringComparison.OrdinalIgnoreCase) ||
xcblBefore12.Equals(MeridianGlobalConstants.XCBL_YES_FLAG, StringComparison.OrdinalIgnoreCase) ||
xcblOwnerOccupied.Equals(MeridianGlobalConstants.XCBL_YES_FLAG, StringComparison.OrdinalIgnoreCase))
{
processData.ShippingSchedule.Pending03 = _meridianResult.Pending03 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
else if (!xcblStreet.Trim().Equals(destinationStreet.Trim(), StringComparison.OrdinalIgnoreCase) ||
!xcblStreetSupplement1.Trim().Equals(destinationStreetSupplement1.Trim(), StringComparison.OrdinalIgnoreCase) ||
!xcblPostalCode.Trim().Equals(destinationPostalCode.Trim(), StringComparison.OrdinalIgnoreCase) ||
!xcblCity.Trim().Equals(destinationCity.Trim(), StringComparison.OrdinalIgnoreCase) ||
!xcblRegionCoded.Trim().Equals(destinationRegionCoded.Trim(), StringComparison.OrdinalIgnoreCase))
{
processData.ShippingSchedule.Pending04 = _meridianResult.Pending04 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
else if ((processData.ShippingSchedule.OrderType != null) &&
(processData.ShippingSchedule.OrderType.Trim().Equals(MeridianGlobalConstants.XCBL_ORDER_TYPE_NPT, StringComparison.OrdinalIgnoreCase) ||
processData.ShippingSchedule.OrderType.Trim().Equals(MeridianGlobalConstants.XCBL_ORDER_TYPE_RRO, StringComparison.OrdinalIgnoreCase)))
{
processData.ShippingSchedule.Approve01 = _meridianResult.Approve01 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
else if ((scheduledShipmentDate > currentDateTime) && (xcblRequestDate <= scheduledShipmentDate10AM.AddDays(-2)))
{
processData.ShippingSchedule.Approve02 = _meridianResult.Approve02 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
else if ((scheduledShipmentDate < currentDateTime) && scheduledDeliveryDate10AM.HasValue && (xcblRequestDate <= scheduledDeliveryDate10AM.Value.AddDays(-2)))
{
processData.ShippingSchedule.Approve03 = _meridianResult.Approve03 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
else if ((xcblScheduledShipDate == scheduledShipmentDate) &&
xcblScheduledDeliveryDate.HasValue && scheduledDeliveryDate.HasValue &&
(xcblScheduledDeliveryDate.Value == scheduledDeliveryDate.Value) &&
xcblSameDay.Equals(MeridianGlobalConstants.XCBL_NO_FLAG, StringComparison.OrdinalIgnoreCase) &&
xcblFirstStop.Equals(MeridianGlobalConstants.XCBL_NO_FLAG, StringComparison.OrdinalIgnoreCase) &&
xcblBefore7.Equals(MeridianGlobalConstants.XCBL_NO_FLAG, StringComparison.OrdinalIgnoreCase) &&
xcblBefore9.Equals(MeridianGlobalConstants.XCBL_NO_FLAG, StringComparison.OrdinalIgnoreCase) &&
xcblBefore12.Equals(MeridianGlobalConstants.XCBL_NO_FLAG, StringComparison.OrdinalIgnoreCase) &&
xcblOwnerOccupied.Equals(MeridianGlobalConstants.XCBL_NO_FLAG, StringComparison.OrdinalIgnoreCase))
{
processData.ShippingSchedule.Approve04 = _meridianResult.Approve04 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
else
{
processData.ShippingSchedule.Pending05 = _meridianResult.Pending05 = MeridianGlobalConstants.XCBL_YES_FLAG;
}
}
else
{
processData.ShippingSchedule.Rejected01 = _meridianResult.Rejected01 = MeridianGlobalConstants.XCBL_YES_FLAG;
processData.ShippingSchedule.Comments = _meridianResult.Comments = MeridianGlobalConstants.XCBL_COMMENT_ORDER_NOT_FOUND;
MeridianSystemLibrary.LogTransaction(processData.WebUserName, processData.FtpUserName, "UsePBSServiceDataAndUpdateFlags", "02.24", "Warning - No Data from PBS WebService", string.Format("Warning - No data got for Order '{0}' from PBS WebService", processData.OrderNumber), processData.CsvFileName, processData.ScheduleID, processData.OrderNumber, null, "Warning 02.24");
}
result = true;
MeridianSystemLibrary.LogPBS(
processData.ScheduleID, processData.OrderNumber,
processData.ShippingSchedule.Approve01, processData.ShippingSchedule.Approve02,
processData.ShippingSchedule.Approve03, processData.ShippingSchedule.Approve04,
processData.ShippingSchedule.Approve05, processData.ShippingSchedule.Pending01,
processData.ShippingSchedule.Pending02, processData.ShippingSchedule.Pending03,
processData.ShippingSchedule.Pending04, processData.ShippingSchedule.Pending05,
"ShippingSchedule", processData.ShippingSchedule.Rejected01, processData.ShippingSchedule.Comments);
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(processData.WebUserName, processData.FtpUserName, "UsePBSServiceDataAndUpdateFlags", "03.13", "Error - Something went wrong", string.Format("Exception - {0}", ex.Message), processData.CsvFileName, processData.ScheduleID, processData.OrderNumber, null, "Error 03.13 - PBS Service Call");
}
return(result);
}
public XElement HelloWorld()
{
return(XElement.Parse(MeridianSystemLibrary.GetMeridian_Status("Hello World", "Hello World", false)));
}
internal static bool SendShippingScheduleResponseRequestFromPBSFTP(XCBL_User currentUser, string fileName, string currentFileData)
{
bool shouldDeletePBSOutFile = false;
try
{
List <PBSData> allPBSData = new List <PBSData>();
var lines = currentFileData.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
if (lines.Count() > 0)
{
for (int i = 1; i < lines.Length; i++)
{
if (!string.IsNullOrWhiteSpace(lines[i]))
{
var values = lines[i].Split(',');
if (values.Length > 4)
{
allPBSData.Add(new PBSData()
{
ScheduleId = values[0],
OrderNumber = values[3],
Status = values[4],
Comment = (values.Length == 6) ? values[5] : null
});
}
}
}
}
if (allPBSData.Count > 0)
{
foreach (var pbsData in allPBSData)
{
var currentShippingScheduleId = pbsData.ScheduleId ?? string.Empty;
var currentOrderNumber = pbsData.OrderNumber ?? string.Empty;
var comment = pbsData.Comment ?? string.Empty;
pbsData.Status = pbsData.Status ?? string.Empty;
currentShippingScheduleId = currentShippingScheduleId.Replace("'", "");
currentOrderNumber = currentOrderNumber.Replace("'", "");
comment = comment.Replace("'", "");
pbsData.Status = pbsData.Status.Replace("'", "");
var responseTypeCoded = MeridianGlobalConstants.XCBL_RESPONSE_TYPE_CODED_SHIPPING_SCHEDULE_RESPONSE_ACCEPTED;
switch (pbsData.Status.Trim().ToUpper())
{
case "A":
responseTypeCoded = MeridianGlobalConstants.XCBL_RESPONSE_TYPE_CODED_SHIPPING_SCHEDULE_RESPONSE_ACCEPTED;
break;
case "R":
responseTypeCoded = MeridianGlobalConstants.XCBL_RESPONSE_TYPE_CODED_SHIPPING_SCHEDULE_RESPONSE_REJECTED;
break;
default:
responseTypeCoded = MeridianGlobalConstants.XCBL_RESPONSE_TYPE_CODED_SHIPPING_SCHEDULE_RESPONSE_REJECTED;
comment = MeridianGlobalConstants.XCBL_COMMENT_RECEIVED_INVALID_CODE_FROM_PBS;
break;
}
if (!string.IsNullOrWhiteSpace(currentShippingScheduleId) && !string.IsNullOrWhiteSpace(currentOrderNumber) && !string.IsNullOrWhiteSpace(responseTypeCoded))
{
var currentStringifiedRequest = MeridianSystemLibrary.GetShippingScheduleRequest(currentUser.WebUsername, currentShippingScheduleId, currentOrderNumber);
if (!string.IsNullOrWhiteSpace(currentStringifiedRequest))
{
MeridianSystemLibrary.LogTransaction(currentUser.WebUsername, currentUser.FtpUsername, "SendShippingScheduleResponseRequestFromPBSFTP", "04.03", "Success - Saved PBS File", string.Format("Success - Saved PBS file : {0}", fileName), fileName, currentShippingScheduleId, currentOrderNumber, null, "Success", currentFileData);
shouldDeletePBSOutFile = true;
var savedShippingScheduleRequest = new XmlDocument();
savedShippingScheduleRequest.LoadXml(currentStringifiedRequest);
/*Below code commented so that later if client will come back on 'AcceptedWithAmendments' then we can use this*/
//if (responseTypeCoded.Trim().Equals(MeridianGlobalConstants.XCBL_RESPONSE_TYPE_CODED_ACCEPTED_WITH_AMENDMENTS, StringComparison.OrdinalIgnoreCase))
// savedShippingScheduleRequest = UpdateShippingScheduleRequest(savedShippingScheduleRequest, values);
MeridianResult meridianResult = new MeridianResult();
meridianResult.XmlDocument = savedShippingScheduleRequest;
meridianResult.OrderNumber = currentOrderNumber;
meridianResult.UniqueID = currentShippingScheduleId;
meridianResult.Comments = comment;
meridianResult.WebUserName = currentUser.WebUsername;
meridianResult.WebPassword = currentUser.WebPassword;
meridianResult.WebHashKey = currentUser.Hashkey;
SendShippingScheduleResponse(meridianResult, responseTypeCoded);
}
else
{
MeridianSystemLibrary.LogTransaction(currentUser.WebUsername, currentUser.FtpUsername, "SendShippingScheduleResponseRequestFromPBSFTP", "05.05", "Warning - No Request Found", string.Format("No Request found for '{0}' PBS FTP file and ShippingScheduleId is '{1}' and OrderNumber is '{2}'", fileName, currentShippingScheduleId, currentOrderNumber), fileName, string.Empty, string.Empty, null, "Warning");
}
}
else
{
MeridianSystemLibrary.LogTransaction(currentUser.WebUsername, currentUser.FtpUsername, "SendShippingScheduleResponseRequestFromPBSFTP", "05.06", "Warning - ShippingScheduleId/OrderNumber/ResponseType/PurposeCoded Empty", string.Format("ShippingScheduleId - {0} /OrderNumber - {1} / ResponseType - {2} Empty for '{3}' PBS FTP file", currentShippingScheduleId, currentOrderNumber, responseTypeCoded, fileName), fileName, string.Empty, string.Empty, null, "Warning");
}
}
}
else
{
MeridianSystemLibrary.LogTransaction(currentUser.WebUsername, currentUser.FtpUsername, "SendShippingScheduleResponseRequestFromPBSFTP", "05.04", "Warning - Empty File", string.Format("Empty File - '{0}' in PBS FTP folder", fileName), fileName, string.Empty, string.Empty, null, "Warning");
}
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(currentUser.WebUsername, currentUser.FtpUsername, "SendShippingScheduleResponseRequestFromPBSFTP", "06.05", "Error - While Parsing PBS File", string.Format("Error - While Parsing PBS FTP File - Inside Catch Block : {0}", ex.Message), fileName, string.Empty, string.Empty, null, "Error 06.05 - PBS File Parsing");
}
return(shouldDeletePBSOutFile);
}
internal static string CreateShippingScheduleResponse(MeridianResult meridianResult, string responseTypeCoded, string purposeCoded, ref string shipScheduleRespId)
{
try
{
var shippingScheduleResponseGUID = shipScheduleRespId = Guid.NewGuid().ToString();
StringBuilder request = new StringBuilder();
var shippingScheduleHeader = meridianResult.XmlDocument.GetElementsByTagName(MeridianGlobalConstants.XCBL_SHIPPING_SCHEDULE_HEADER).Item(0);
request.Append("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
request.Append("<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns=\"rrn:org.xcbl:schemas/xcbl/v4_0/materialsmanagement/v1_0/materialsmanagement.xsd\" xmlns:core=\"rrn:org.xcbl:schemas/xcbl/v4_0/core/core.xsd\">");
request.Append("<soapenv:Header>");
request.Append("<Credentials>");
request.Append("<UserName>");
request.Append(Encryption.Encrypt(meridianResult.WebUserName, meridianResult.WebHashKey));
request.Append("</UserName>");
request.Append("<Password>");
request.Append(Encryption.Encrypt(meridianResult.WebPassword, meridianResult.WebHashKey));
request.Append("</Password>");
request.Append("<Hashkey>");
request.Append(meridianResult.WebHashKey);
request.Append("</Hashkey>");
request.Append("</Credentials>");
request.Append("</soapenv:Header>");
request.Append("<soapenv:Body>");
request.Append("<ShippingScheduleResponse>");
request.Append("<ShippingScheduleResponseHeader>");
request.Append("<ScheduleResponseID>");
request.Append(shippingScheduleResponseGUID);
request.Append("</ScheduleResponseID>");
request.Append("<ScheduleResponseIssueDate>");
request.Append(DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss.fff"));
request.Append("</ScheduleResponseIssueDate>");
request.Append("<ShippingScheduleReference>");
request.Append("<core:RefNum>");
request.Append(meridianResult.OrderNumber);
request.Append("</core:RefNum>");
request.Append("</ShippingScheduleReference>");
request.Append("<Purpose>");
request.Append("<core:PurposeCoded>");
request.Append(purposeCoded);
request.Append("</core:PurposeCoded>");
request.Append("</Purpose>");
request.Append("<ResponseType>");
request.Append("<core:ResponseTypeCoded>");
request.Append(responseTypeCoded);
request.Append("</core:ResponseTypeCoded>");
request.Append("</ResponseType>");
request.Append("<ShippingScheduleHeader>");
request.Append(shippingScheduleHeader.InnerXml);
request.Append("</ShippingScheduleHeader>");
if (!string.IsNullOrWhiteSpace(meridianResult.Comments))
{
request.Append("<ShippingScheduleResponseHeaderNote>");
request.Append(meridianResult.Comments);
request.Append("</ShippingScheduleResponseHeaderNote>");
}
request.Append("</ShippingScheduleResponseHeader>");
request.Append("</ShippingScheduleResponse>");
request.Append("</soapenv:Body>");
request.Append("</soapenv:Envelope>");
var currentXmlDocument = new XmlDocument();
currentXmlDocument.LoadXml(request.ToString());
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "CreateShippingScheduleResponse", "04.01", "Success - Created ShippingScheduleResponse Request", "Shipping Schedule Response Request", "No File Name", shippingScheduleResponseGUID, meridianResult.OrderNumber, currentXmlDocument, "Success");
return(request.ToString());
}
catch (Exception ex)
{
MeridianSystemLibrary.LogTransaction(meridianResult.WebUserName, meridianResult.FtpUserName, "CreateShippingScheduleResponse", "06.02", "Error - Create ShippingScheduleResponse Request", string.Format("Error - While creating SSR Request: {0}", ex.Message), meridianResult.FileName, meridianResult.UniqueID, meridianResult.OrderNumber, meridianResult.XmlDocument, "Error 06.02 - Create AWC SSR Request");
return(string.Empty);
}
}
