public List <WebOrderHeaderModel> GetPendingWebOrderAcknowledgments()
{
DbDataReader idrOrder = null;
WebOrderHeaderModel ObjOrder = null;
try
{
List <WebOrderHeaderModel> orderList = new List <WebOrderHeaderModel>();
idrOrder = this.DataAcessService.ExecuteQuery(OrderSql["GetWebOrdersForPOA"]);
if (idrOrder != null && idrOrder.HasRows)
{
while (idrOrder.Read())
{
ObjOrder = new WebOrderHeaderModel();
ObjOrder.WebId = ExtensionMethods.GetInt32(idrOrder, "web_id");
ObjOrder.DetailsStatus = ExtensionMethods.GetInt32(idrOrder, "detail_changes_status");
ObjOrder.SenderAddress = ExtensionMethods.GetString(idrOrder, "sender_edi").ToString();
ObjOrder.ReceiverAddress = ExtensionMethods.GetString(idrOrder, "receiver_edi").ToString();
ObjOrder.MessageRefference = ExtensionMethods.GetString(idrOrder, "msg_ref").ToString();
ObjOrder.OrderResponseNo = ExtensionMethods.GetString(idrOrder, "order_response_no").ToString();
ObjOrder.ResponseDate = ExtensionMethods.GetDateTime(idrOrder, "response_date");
ObjOrder.DeliveryDate = ExtensionMethods.GetDateTime(idrOrder, "date_required");
ObjOrder.BuyerOrderNo = ExtensionMethods.GetString(idrOrder, "buyer_order_no").ToString();
ObjOrder.PromotionNo = ExtensionMethods.GetString(idrOrder, "promotional_deal_no").ToString();
ObjOrder.BuyingAddress = ExtensionMethods.GetString(idrOrder, "buying_add_gs1_cd").ToString();
ObjOrder.ShippingAddress = ExtensionMethods.GetString(idrOrder, "shipping_add_gs1_cd").ToString();
ObjOrder.SupplierAddress = ExtensionMethods.GetString(idrOrder, "supplier_add_gs1_cd").ToString();
ObjOrder.TotalAmount = ExtensionMethods.GetDouble(idrOrder, "order_tot_amt");
ObjOrder.ItemCount = ExtensionMethods.GetInt32(idrOrder, "tot_no_of_items");
ObjOrder.AS2Identifier = ExtensionMethods.GetString(idrOrder, "as2_identifier").ToString();
orderList.Add(ObjOrder);
}
}
return(orderList);
}
catch
{
throw;
}
finally
{
if (idrOrder != null && (!idrOrder.IsClosed))
{
idrOrder.Close();
}
}
}
//---------------------------------------------------------------------------------------
/// <summary>
/// Inserts the web order header.
/// This is Soooo prone for race conditions as this is not the only application writing
/// to this table. Workaround taken now is to schedule the two applications in
/// non conflicting windows. But THIS SHOULD BE PROPERLY ADDRESSED
/// </summary>
/// <param name="orderHeader">The order header.</param>
/// <returns>Success or failure</returns>
///---------------------------------------------------------------------------------------
public bool InsertWebOrderHeader(WebOrderHeaderModel orderHeader)
{
bool isSuccess = false;
int NoRecord = 0;
try
{
int assigneeNo = 0;
float freight = 0.000F;
string status = "Processing";
DbInputParameterCollection paramCollection = new DbInputParameterCollection()
{
DbInputParameter.GetInstance("@WebId",
DbType.Int32,
orderHeader.WebId),
//DbInputParameter.GetInstance("@CustomerCode",
//DbType.String,
//orderHeader.CustomerCode),
DbInputParameter.GetInstance("@OrderDate",
DbType.DateTime,
orderHeader.OrderDate),
DbInputParameter.GetInstance("@DateRequired",
DbType.String,
orderHeader.DateRequired),
DbInputParameter.GetInstance("@Comments",
DbType.String,
orderHeader.Comments),
DbInputParameter.GetInstance("@OrderNote",
DbType.String,
orderHeader.OrderNote),
DbInputParameter.GetInstance("@PurchaseCode",
DbType.String,
orderHeader.PurchaseCode),
DbInputParameter.GetInstance("@Status",
DbType.String,
status),
DbInputParameter.GetInstance("@IsAckReq",
DbType.Int32,
orderHeader.IsAckRequired),
DbInputParameter.GetInstance("@CustomerCode",
DbType.String,
orderHeader.CustomerCode),
DbInputParameter.GetInstance("@AssigneeNo",
DbType.Int32,
assigneeNo),
DbInputParameter.GetInstance("@Freight",
DbType.Int32,
freight),
DbInputParameter.GetInstance("@IsSaved",
DbType.String,
string.Empty), // OR application only display orders with is_saved blank
DbInputParameter.GetInstance("@IsProcessed",
DbType.Int32,
Convert.ToInt32("0")),
DbInputParameter.GetInstance("@DetailStatus",
DbType.Int32,
Convert.ToInt32("0")),
DbInputParameter.GetInstance("@SenderAddress",
DbType.String,
orderHeader.SenderAddress),
DbInputParameter.GetInstance("@ReceiverAddress",
DbType.String,
orderHeader.ReceiverAddress),
DbInputParameter.GetInstance("@MsgRef",
DbType.String,
orderHeader.MessageRefference),
DbInputParameter.GetInstance("@BuyerOrderNo",
DbType.String,
orderHeader.BuyerOrderNo),
DbInputParameter.GetInstance("@PromotionNo",
DbType.String,
orderHeader.PromotionNo),
DbInputParameter.GetInstance("@BuyingAddress",
DbType.String,
orderHeader.BuyingAddress),
DbInputParameter.GetInstance("@ShippingAddress",
DbType.String,
orderHeader.ShippingAddress),
DbInputParameter.GetInstance("@SupplierAddress",
DbType.String,
orderHeader.SupplierAddress),
DbInputParameter.GetInstance("@TotalAmount",
DbType.Decimal,
orderHeader.TotalAmount),
DbInputParameter.GetInstance("@ItemCount",
DbType.Int32,
orderHeader.ItemCount),
DbInputParameter.GetInstance("@AS2Identifier",
DbType.String,
orderHeader.AS2Identifier),
};
NoRecord = this.DataAcessService.ExecuteNonQuery(OrderSql["InsertWebOrderHeader"], paramCollection);
if (NoRecord > 0)
{
isSuccess = true;
}
else
{
isSuccess = false;
}
}
catch (Exception ex)
{
throw;
}
return(isSuccess);
}
/// <summary>
/// Processes AS2 wrapped EDI message
/// </summary>
/// <param name="request">The request.</param>
/// <param name="dropLocation">The drop location.</param>
public void Process(HttpRequest request, string dropLocation)
{
string sTo = request.Headers["AS2-To"];
string sFrom = request.Headers["AS2-From"];
string dtf = $"{sFrom}_{sTo}_" + DateTime.Now.ToString("ddMMyyyy_hh_mm_ss") + ".txt";
string filename = $"AS2_transaction_{dtf}";
string extractfilename = $"AS2_transaction_extract_{dtf}";
byte[] data = request.BinaryRead(request.TotalBytes);
bool isEncrypted = request.ContentType.Contains("application/pkcs7-mime");
bool isSigned = request.ContentType.Contains("application/pkcs7-signature");
string message = string.Empty;
Log.DebugFormat($"Process\n" +
$"\tFrom : {sFrom}\n" +
$"\tTo : {sTo}\n" +
$"\tIs Signed : {isSigned}\n" +
$"\tIs Encrypted : {isEncrypted}\n" +
$"\tContentType string : {request.ContentType}\n" +
$"Dump file name : {filename}\n");
if (!isSigned && !isEncrypted) // not signed and not encrypted
{
message = System.Text.ASCIIEncoding.ASCII.GetString(data);
}
if (isEncrypted) // encrypted and signed inside
{
byte[] decryptedData;
try
{
Log.Debug("Decrypting......");
decryptedData = AS2Encryption.Decrypt(data);
Log.Debug("Decrypting SUCCESS.");
}
catch (Exception ex)
{
Log.Error($"Exception during decrypting {ex.Message}");
if (ex.InnerException != null)
{
Log.Error($"Inner Exception during decoding {ex.InnerException.Message}");
}
throw;
}
string messageWithContentTypeLineAndMIMEHeaders = System.Text.ASCIIEncoding.ASCII.GetString(decryptedData);
// when encrypted, the Content-Type line is actually stored in the start of the message
// Require multi split done by 'ExtractPayload'
// First segment is data payload - THIS IS EDIFACT/XML data
// Second payload is a public key file [Not essential]
int firstBlankLineInMessage = messageWithContentTypeLineAndMIMEHeaders.IndexOf(Environment.NewLine + Environment.NewLine);
string contentType = messageWithContentTypeLineAndMIMEHeaders.Substring(0, firstBlankLineInMessage);
message = AS2MIMEUtilities.ExtractPayload(messageWithContentTypeLineAndMIMEHeaders, contentType);
try
{
System.IO.File.WriteAllText($"{Util.ConfigValues.DropLocation}\\{extractfilename}", message);
Log.Debug($"Message Extract written to file {Util.ConfigValues.DropLocation}\\{extractfilename}");
}
catch (Exception ex)
{
Log.Error($"Failed to write message extract to file : {Util.ConfigValues.DropLocation}\\{extractfilename}\n" +
$"Exception : {ex.Message}\n");
}
string signature = "";
if (isSigned)
{
//int SecondBlankLineInMessage = message.IndexOf(Environment.NewLine + Environment.NewLine);
int signatureHeaderStart = message.IndexOf(Environment.NewLine + "--_");
string messageWithSignature = message;
Log.DebugFormat($"Message with embedded signature\n" +
$"\tSignature start found at : {signatureHeaderStart}\n" +
$"\tSignature start found invalid format : {message.IndexOf('\n' + "--_")}\n");
message = message.Substring(0, signatureHeaderStart);
string signaturePart = messageWithSignature.Substring(signatureHeaderStart);
int signatureStart = signaturePart.IndexOf(Environment.NewLine + Environment.NewLine);
signature = signaturePart.Substring(signatureStart + 4);
Log.Debug($"\n----------------------------------------------------------------------------------------------------------------------------------\n" +
$"Extracted EDI Message\n {message}\n" +
$"----------------------------------------------------------------------------------------------------------------------------------\n");
//TODO :: Kavisha - uncomment after testing
if (AS2Encryption.validateSignature(signature) == false)
{
Log.Error($"Invalid signature {signature}");
return;
}
}
else
{
int signatureHeaderStart = message.IndexOf(Environment.NewLine + "--_");
// Check if it is marked inside the mesage payload
if (signatureHeaderStart >= 0)
{
//int SecondBlankLineInMessage = message.IndexOf(Environment.NewLine + Environment.NewLine);
string messageWithSignature = message;
Log.DebugFormat($"Message with embedded signature\n" +
$"\tSignature start found at : {signatureHeaderStart}\n" +
$"\tSignature start found invalid format : {message.IndexOf('\n' + "--_")}\n");
message = message.Substring(0, signatureHeaderStart);
string signaturePart = messageWithSignature.Substring(signatureHeaderStart);
int signatureStart = signaturePart.IndexOf(Environment.NewLine + Environment.NewLine);
signature = signaturePart.Substring(signatureStart + 4);
Log.Debug($"\n----------------------------------------------------------------------------------------------------------------------------------\n" +
$"Extracted EDI Message\n {message}\n" +
$"----------------------------------------------------------------------------------------------------------------------------------\n");
//TODO :: Kavisha - uncomment after testing
if (AS2Encryption.validateSignature(signature) == false)
{
Log.Error($"Invalid signature {signature}");
return;
}
}
else
{
Log.Error("Invalid payload [Not signed]");
}
}
}
else
{
Log.Debug("Non-Encrypted..");
if (isSigned)
{
Log.Debug("Non-Encrypted signed..");
string messageWithMIMEHeaders = System.Text.ASCIIEncoding.ASCII.GetString(data);
message = AS2MIMEUtilities.ExtractPayload(messageWithMIMEHeaders, request.Headers["Content-Type"]);
Log.Debug($"Extracted message {message}");
string signaturePart = messageWithMIMEHeaders.Substring(message.Length);
string signature = AS2MIMEUtilities.ExtractPayload(signaturePart, request.Headers["Content-Type"]);
Log.Debug($"Extracted signature {signature}");
if (AS2Encryption.validateSignature(signature) == false)
{
Log.Error($"Invalid signature {signature}");
return;
}
}
}
try
{
System.IO.File.WriteAllText($"{Util.ConfigValues.DropLocation}\\{filename}", message);
}
catch (Exception ex)
{
Log.Error($"Failed to write dump to file : {Util.ConfigValues.DropLocation}\\{filename}\n" +
$"Exception : {ex.Message}\n");
}
var grammar = EdiGrammar.NewEdiFact();
var interchange = default(Interchange);
using (var stream = new StreamReader($"{Util.ConfigValues.DropLocation}\\{filename}"))
{
Quote quoteMessage = null;
try
{
interchange = new EdiSerializer().Deserialize <Interchange>(stream, grammar);
quoteMessage = interchange.QuoteMessage;
}
catch (Exception ex)
{
Log.Error($"Content to EDI deserialization error : {ex.Message}\n" +
$"Payload File : {Util.ConfigValues.DropLocation}\\{filename}\n");
throw;
}
try
{
if (quoteMessage != null)
{
if (quoteMessage.MessageName != "220")
{
return;
}
WebOrderHeaderModel webOrder = new WebOrderHeaderModel();
webOrder.AS2Identifier = request.Headers["AS2-From"];
quoteMessage.fillWebOrder(webOrder, interchange);
InsertOrderToDB(webOrder);
Log.Info("Order inserted ----------------");
Log.Info(webOrder.ToString());
}
}
catch (Exception ex)
{
Log.Error($"Order insertion error : {ex.Message}");
if (ex.InnerException != null)
{
Log.Error($"\tInner Exception : {ex.InnerException.Message}");
}
throw;
}
}
}
/// <summary>
/// Inserts the order to database.
/// </summary>
/// <param name="webOrder">The web order.</param>
private void InsertOrderToDB(WebOrderHeaderModel webOrder)
{
OrderDataService OrderDataServ = null;
try
{
OrderDataServ = HttpContext.Current.Application["OrderDataServ"] as OrderDataService;
OrderDataServ.IncrementPFDWebOrderID(); // Increment before fetch
webOrder.WebId = OrderDataServ.GetNextPFDWebOrderId();
webOrder.CustomerCode = OrderDataServ.GetCustomerCodeById(webOrder.BillTo);
string ackCustCode = OrderDataServ.GetAckCustCode(webOrder.CustomerCode);
if (!string.IsNullOrEmpty(ackCustCode))
{
webOrder.IsAckRequired = 1;
}
else
{
webOrder.IsAckRequired = 0;
}
if (string.IsNullOrEmpty(webOrder.CustomerCode) == false)
{
webOrder.OrderNote = " ";
}
}
catch (QueryExecutionException ex)
{
Log.Error($"Query execution exception {ex.Message}");
throw;
}
webOrder.Comments = " ";
bool success = false;
try
{
success = OrderDataServ.InsertWebOrderHeader(webOrder);
}
catch (QueryExecutionException ex)
{
Log.Error($"Order header insertion failed. {ex.Message} + Inner Ex : {ex.InnerException.Message}");
throw;
}
if (false == success)
{
return;
}
foreach (WebOrderDetailModel wod in webOrder.WebOrderDetailList)
{
try
{
wod.WebId = webOrder.WebId;
if (string.IsNullOrEmpty(wod.CatlogCode))
{
wod.CatlogCode = OrderDataServ.GetCatlogCodeByGTIN(wod.GTINCode);
wod.ProductNote = wod.CatlogCode;
}
success = OrderDataServ.InsertWebOrderDetail(wod);
}
catch (QueryExecutionException ex)
{
Log.Error($"Order detail insertion failed. {ex.Message} + Inner Ex : {ex.InnerException.Message}, rolling back.");
OrderDataServ.RollBackOrderReferences(webOrder.WebId);
throw;
}
if (success == false)
{
Log.Error($"Order detail inserttion failed for web order id : {webOrder.WebId} , rolling back.");
OrderDataServ.RollBackOrderReferences(webOrder.WebId);
return;
}
}
}
private Interchange CovertToInterChange(WebOrderHeaderModel webOrderHeader, List <WebOrderDetailModel> webOrderDetail)
{
Interchange interchange = new Interchange();
interchange.RecipientId = webOrderHeader.SenderAddress;
interchange.SenderId = webOrderHeader.ReceiverAddress;
Quote quote = new Quote();
quote.MessageType = "ORDERS";
quote.ReleaseNumber = "01B";
quote.AssociationAssignedCode = "EAN010";
quote.DocumentNumber = webOrderHeader.OrderResponseNo;
quote.ReleaseNumber = "01B";
quote.MessageFunction = webOrderHeader.DetailsStatus.ToString();
DTM responseDate = new DTM();
DTM deliveryDate = new DTM();
responseDate.ID = 137;
responseDate.DateTime = webOrderHeader.ResponseDate;
responseDate.Code = 102;
deliveryDate.ID = 2;
deliveryDate.DateTime = webOrderHeader.DeliveryDate;
deliveryDate.Code = 102;
quote.MessageDate = responseDate;
quote.DeliveryDate = deliveryDate;
quote.DocumentNumber = webOrderHeader.BuyerOrderNo;
NAD buingAddress = new NAD();
NAD shippingAddress = new NAD();
NAD supplierAddress = new NAD();
buingAddress.PartyQualifier = "BY";
buingAddress.PartyId = webOrderHeader.BuyingAddress;
shippingAddress.PartyQualifier = "ST";
shippingAddress.PartyId = webOrderHeader.ShippingAddress;
supplierAddress.PartyQualifier = "SU";
supplierAddress.PartyId = webOrderHeader.SupplierAddress;
quote.NAD = new List <NAD>();
quote.NAD.Add(buingAddress);
quote.NAD.Add(shippingAddress);
quote.NAD.Add(supplierAddress);
List <LineItem> lineList = new List <LineItem>();
int index = 1;
foreach (WebOrderDetailModel item in webOrderDetail)
{
LineItem lineItem = new LineItem();
lineItem.GTIN = item.GTINCode;
lineItem.Code = item.ItemStatus.ToString();
lineItem.LineNumber = index;
lineItem.itemTypeIDCode = "SRV";
Price priceItem = new Price();
priceItem.Code = "AAF";
priceItem.Amount = Convert.ToDecimal(item.ItemPrice);
QTY quantityItem = new QTY();
quantityItem.Quantity = Convert.ToInt32(item.BackOrderQty);
quantityItem.QuantityType = "113";
lineItem.Price = priceItem;
lineItem.QTY = quantityItem;
index++;
lineList.Add(lineItem);
}
quote.Lines = lineList;
interchange.QuoteMessage = quote;
return(interchange);
}
//---------------------------------------------------------------
public void fillWebOrder(WebOrderHeaderModel webOrder, Interchange interchange)
{
webOrder.Comments = this.freeTextElement.value;
webOrder.DateRequired = this.DeliveryDate.DateTime;
webOrder.OrderDate = this.MessageDate.DateTime;
webOrder.PurchaseCode = this.DocumentNumber;
webOrder.Status = "Processing"; // TODO // 29 - Accept 27 - Reject 4-Change
//webOrder.IsAckRequired = interchange.AckRequest;
webOrder.SenderAddress = interchange.SenderId;
webOrder.ReceiverAddress = interchange.RecipientId;
webOrder.MessageRefference = this.MessageRef;
webOrder.OrderResponseNo = "";
// webOrder.ResponseDate = this.MessageDate.DateTime;
// webOrder.DeliveryDate = this.DeliveryDate.DateTime;
webOrder.BuyerOrderNo = this.DocumentNumber;
webOrder.PromotionNo = "";
webOrder.TotalAmount = 0;
foreach (NAD NameAddress in this.NAD)
{
if (NameAddress.PartyId == "ST")
{
webOrder.OrderNote = NameAddress.AddressString;
webOrder.BillTo = 540; // TODO
}
if (NameAddress.PartyQualifier == "ST")
{
webOrder.ShippingAddress = NameAddress.PartyId;
}
else if (NameAddress.PartyQualifier == "BY")
{
webOrder.BuyingAddress = NameAddress.PartyId;
}
else if (NameAddress.PartyQualifier == "SU")
{
webOrder.SupplierAddress = NameAddress.PartyId;
}
}
if (Lines.Count > 0)
{
webOrder.WebOrderDetailList = new List <WebOrderDetailModel>();
foreach (LineItem li in this.Lines)
{
WebOrderDetailModel wod = new WebOrderDetailModel();
wod.CatlogCode = li.PIA.ItemCode;
wod.ProductNote = li.PIA.ItemCode;
wod.OrderQty = li.QTY.Quantity;
wod.UnitCost = Decimal.ToDouble(li.Price.Amount);
wod.UnitPrice = Decimal.ToDouble(li.Price.Amount);
wod.GTINCode = li.GTIN;
wod.ItemStatus = 0; //3-changed 5-accepted 7-not accepted
//wod.BackOrderQty = li.QTY.Quantity;
//wod.ItemPrice = Decimal.ToDouble(li.Price.Amount);
webOrder.WebOrderDetailList.Add(wod);
}
}
webOrder.ItemCount = interchange.QuoteMessage.Lines.Count;
webOrder.DetailsStatus = 0;
}
