protected void Application_Start()
{
try
{
log4net.Config.XmlConfigurator.Configure();
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
OrderDataServ = new OrderDataService();
HttpContext.Current.Application["OrderDataServ"] = OrderDataServ;
if (ConfigValues.SendAcknowledgement == "On")
{
SetTimer();
//Util.AS2Acknowledge acknowledgeClass = new Util.AS2Acknowledge();
//acknowledgeClass.SendPOAcknowledgements();
}
}
catch (Exception ex)
{
if (Log != null)
{
Log.Error($"Application Init failed. {ex.Message}");
}
}
Log.Info("Application Init.");
}
public CartController()
{
var dataService = new Irbis.DataService.Init();
_сartDataService = dataService.СartDataService;
_orderDataService = dataService.OrderDataService;
}
//
// GET: /Manage/Index
public async Task <ActionResult> Index(ManageMessageId?message)
{
var userId = User.Identity.GetUserId();
model.Orders = OrderDataService.UserOrders(userId);
model.CustomerAccountInfo = CustomerDataService.GetCustomer(userId);
//ViewBag.StatusMessage =
// message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
// : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
// : message == ManageMessageId.SetTwoFactorSuccess ? "Your two-factor authentication provider has been set."
// : message == ManageMessageId.Error ? "An error has occurred."
// : message == ManageMessageId.AddPhoneSuccess ? "Your phone number was added."
// : message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed."
// : "";
//var userId = User.Identity.GetUserId();
//var model = new IndexViewModel
//{
// HasPassword = HasPassword(),
// PhoneNumber = await UserManager.GetPhoneNumberAsync(userId),
// TwoFactor = await UserManager.GetTwoFactorEnabledAsync(userId),
// Logins = await UserManager.GetLoginsAsync(userId),
// BrowserRemembered = await AuthenticationManager.TwoFactorBrowserRememberedAsync(userId)
//};
return(View(model));
}
// FIXME: Disable for now. AsAsyncEnumerable issue.
//[TestMethod]
public void Get_Orders()
{
// Arrange
var orderDataService = new OrderDataService(sourceService.Object, mockILoggerFactory.Object.CreateLogger <OrderDataService>());
var rnd = new Random();
var ordersQty = 20;
var currDate = DateTime.UtcNow;
var itms = Enumerable.Range(1, ordersQty).Select(x => new Order()
{
OrderId = rnd.Next(x * 1000),
OrderStatusId = rnd.Next(x * 1000),
DateCreated = currDate.AddDays(x)
}.To <DbOrder>()).ToList();
var idForCheck = itms[new Random().Next(ordersQty)].OrderId;
var firstNum = rnd.Next(ordersQty - 1);
var firstDate = itms[firstNum].DateCreated;
var secondNum = rnd.Next(firstNum, ordersQty);
var secondDate = itms[secondNum].DateCreated;
var ordersMock = TestHelper.ToDbSetMock(itms);
sourceService.Setup(x => x.Orders).Returns(ordersMock.Object);
sourceService.Setup(x => x.Set <DbOrder>()).Returns(ordersMock.Object);
// Action
var result = orderDataService.GetOrders().Result;
// Assert
ordersMock.Verify(x => x.Where(It.IsAny <Expression <Func <DbOrder, bool> > >()), Times.Exactly(1));
sourceService.Verify(x => x.Set <DbOrder>(), Times.Exactly(4));
Assert.AreEqual(ordersQty, result.Count);
}
public void Update_Order()
{
// Arrange
var orderDataService = new OrderDataService(sourceService.Object, iLoggerFactory.Object.CreateLogger <OrderDataService>());
var requestOrder = new Order()
{
Id = 1,
Amount = 29.99M,
DateCreated = DateTime.UtcNow
};
var itms = new List <DbOrder>()
{
requestOrder.OrderToDbOrder()
};
var ordersMock = TestHelper.ToDbSetMock(itms);
ordersMock.Setup(d => d.UpdateRange(It.IsAny <DbOrder[]>())).Callback <DbOrder[]>((s) => {
s.ToList().ForEach(fe => {
var fod = itms.FirstOrDefault(v => v.Id == fe.Id);
if (fod != null)
{
fod.DateCreated = fe.DateCreated;
fod.Amount = fe.Amount;
}
});
});
sourceService.Setup(x => x.Orders).Returns(ordersMock.Object);
sourceService.Setup(x => x.Set <DbOrder>()).Returns(ordersMock.Object);
var ord = new Order()
{
Id = 1,
Amount = 77.77M,
DateCreated = DateTime.UtcNow.AddDays(15)
}.OrderToDbOrder();
var badOrder = new Order()
{
Id = Int32.MaxValue,
Amount = 1.1M,
DateCreated = DateTime.UtcNow.AddDays(30)
}.OrderToDbOrder();
// Action
orderDataService.Update(ord);
orderDataService.Update(badOrder);
// Assert
ordersMock.Verify(x => x.UpdateRange(It.IsAny <DbOrder[]>()), Times.Exactly(2));
Assert.AreEqual(1, itms.Count);
var updatedItem = itms.First();
Assert.AreEqual(ord.Amount, updatedItem.Amount);
Assert.AreEqual(ord.DateCreated, updatedItem.DateCreated);
}
protected async Task GetSales()
{
DateTime dt = new DateTime(int.Parse(SelectedYear), int.Parse(SelectedMonth), 1);
var orders = await OrderDataService.GetPagedOrderForMonth(dt, pageNumber.Value, 5);
paginatedList = new PaginatedList <OrdersForMonthListViewModel>(orders.OrdersForMonth.ToList(), orders.Count, pageNumber.Value, 5);
ordersList = paginatedList.Items;
StateHasChanged();
}
public void Remove_Order()
{
// Arrange
var orderDataService = new OrderDataService(sourceService.Object, iLoggerFactory.Object.CreateLogger <OrderDataService>());
var itms = new List <DbOrder>()
{
new Order()
{
Id = 753,
Amount = 555M,
DateCreated = DateTime.UtcNow
}.OrderToDbOrder(),
new Order()
{
Id = new Random().Next(),
Amount = 666M,
DateCreated = DateTime.UtcNow
}.OrderToDbOrder(),
new Order()
{
Id = 1,
Amount = 555M,
DateCreated = DateTime.UtcNow
}.OrderToDbOrder(),
};
var ordersMock = TestHelper.ToDbSetMock(itms);
ordersMock.Setup(x => x.RemoveRange(It.IsAny <DbOrder[]>())).Callback <DbOrder[]>((s) =>
{
s.ToList().ForEach(fe =>
{
itms.RemoveAll(x => x.Id == fe.Id);
});
});
sourceService.Setup(x => x.Orders).Returns(ordersMock.Object);
sourceService.Setup(x => x.Set <DbOrder>()).Returns(ordersMock.Object);
var ordersCount = itms.Count;
for (var i = itms.Count - 1; i >= 0; i--)
{
var restCount = itms.Count;
var orderForDelete = itms[i];
// Action
orderDataService.Remove(orderForDelete.Id);
// Assert
ordersMock.Verify(x => x.RemoveRange(It.IsAny <DbOrder[]>()), Times.Exactly(ordersCount - i));
Assert.AreEqual(restCount - 1, itms.Count);
Assert.IsTrue(itms.TrueForAll(x => x.Id != orderForDelete.Id));
}
}
public void Throws_When_Invalid_OrderAddressZipCode_Is_Passed(string addressZipCode)
{
var orderTotal = 123;
var userId = "o1";
var orderId = "o1";
var orderAddressCity = "City";
var orderAddressNumber = "Addr";
var orderAddressStreet = "Strt";
var orderAddressZipCode = addressZipCode;
var singlePie = PieListMock
.MockPieCatalog()
.ToList()
.FirstOrDefault();
var pies = new List <Pie>()
{
singlePie
};
var orderAddress = new Address()
{
City = orderAddressCity,
Number = orderAddressNumber,
Street = orderAddressStreet,
ZipCode = orderAddressZipCode
};
var order = new Order()
{
Address = orderAddress,
OrderTotal = orderTotal,
Pies = pies,
UserId = userId,
OrderId = orderId
};
var requestProviderMock = new Mock <IRequestProvider>();
requestProviderMock
.Setup(e => e.PostAsync <Order>(It.IsAny <string>(), It.IsAny <Order>(), It.IsAny <string>()))
.Returns(Task.FromResult <Order>(order));
var orderDataService = new OrderDataService(requestProviderMock.Object);
Assert.ThrowsAsync <OrderDataServiceException>(
async() => await orderDataService.AddOrderAsync(order));
}
public void Add_Order()
{
// Arrange
var orderDataService = new OrderDataService(sourceService.Object, iLoggerFactory.Object.CreateLogger <OrderDataService>());
var rnd = new Random();
var ordersQty = 20;
var currDate = DateTime.UtcNow;
var orders = Enumerable.Range(1, ordersQty).Select(x => new Order()
{
Amount = rnd.Next(x * 1000) + new Random().Next(x) / 100,
DateCreated = currDate.AddDays(x)
}).ToList();
var itms = new List <DbOrder>();
var ordersMock = TestHelper.ToDbSetMock(itms);
ordersMock.Setup(x => x.AddRangeAsync(It.IsAny <DbOrder[]>())).Callback <DbOrder[]>((s) =>
{
s.ToList().ForEach(fe =>
{
itms.Add(fe);
});
}).Returns(Task.Run(() => { }));
sourceService.Setup(x => x.Orders).Returns(ordersMock.Object);
sourceService.Setup(x => x.Set <DbOrder>()).Returns(ordersMock.Object);
var ord = new Order()
{
Id = 1,
Amount = 77.77M,
DateCreated = DateTime.UtcNow.AddDays(15)
}.OrderToDbOrder();
var badOrder = new Order()
{
Id = Int32.MaxValue,
Amount = 1.1M,
DateCreated = DateTime.UtcNow.AddDays(30)
}.OrderToDbOrder();
// Action
orders.ForEach(o => { orderDataService.Add(o.OrderToDbOrder()).Wait(); });
// Assert
ordersMock.Verify(x => x.AddRangeAsync(It.IsAny <DbOrder[]>()), Times.Exactly(orders.Count));
Assert.AreEqual(orders.Count, itms.Count);
orders.ForEach(os =>
{
Assert.IsTrue(itms.Any(x => x.Amount == os.Amount && x.DateCreated == os.DateCreated));
});
}
public bool UpdateWebOrderSyncStatus(int webId, DateTime responseDate)
{
OrderDataService OrderDataServ = new OrderDataService();
try
{
//OrderDataServ = HttpContext.Current.Application["OrderDataServ"] as OrderDataService;
return(OrderDataServ.UpdateWebOrderSyncStatus(webId, responseDate));
}
catch (Exception ex)
{
Log.Error($"Order acknowledge status update failed. {ex.Message} + Inner Ex : {ex.InnerException.Message}");
throw;
}
}
public List <WebOrderDetailModel> GetPOADetailList(int webId)
{
OrderDataService OrderDataServ = new OrderDataService();
try
{
// OrderDataServ = HttpContext.Current.Application["OrderDataServ"] as OrderDataService;
return(OrderDataServ.GetWebOrderDetailsForAck(webId));
}
catch (Exception ex)
{
Log.Error($"Order detail read failed. {ex.Message} + Inner Ex : {ex.InnerException.Message}");
throw;
}
}
public List <WebOrderHeaderModel> GetPendingPOAckList()
{
OrderDataService OrderDataServ = new OrderDataService();
try
{
// OrderDataServ = HttpContext.Current.Application["OrderDataServ"] as OrderDataService;
return(OrderDataServ.GetPendingWebOrderAcknowledgments());
}
catch (Exception ex)
{
Log.Error($"Order header read failed. {ex.Message} + Inner Ex : {ex.InnerException.Message}");
throw;
}
}
public void Throws_When_Invalid_Order_Is_Passed()
{
Order order = null;
var requestProviderMock = new Mock <IRequestProvider>();
requestProviderMock
.Setup(e => e.PostAsync <Order>(It.IsAny <string>(), It.IsAny <Order>(), It.IsAny <string>()))
.Returns(Task.FromResult <Order>(order));
var orderDataService = new OrderDataService(requestProviderMock.Object);
Assert.ThrowsAsync <OrderDataServiceException>(
async() => await orderDataService.AddOrderAsync(order));
}
// FIXME: Disable for now. AsAsyncEnumerable issue.
//[TestMethod]
public void Get_Orders()
{
// Arrange
var orderDataService = new OrderDataService(sourceService.Object, iLoggerFactory.Object.CreateLogger <OrderDataService>());
var rnd = new Random();
var ordersQty = 40;
var currDate = DateTime.UtcNow;
var itms = Enumerable.Range(1, ordersQty).Select(x => new Order()
{
Amount = rnd.Next(x * 1000) + new Random().Next(x) / 100,
DateCreated = currDate.AddDays(x)
}.OrderToDbOrder()).ToList();
var idForCheck = itms[new Random().Next(ordersQty)].Id;
var badIdForCheck = -10000;
var firstNum = rnd.Next(ordersQty - 1);
var firstDate = itms[firstNum].DateCreated;
var secondNum = rnd.Next(firstNum, ordersQty);
var secondDate = itms[secondNum].DateCreated;
var ordersMock = TestHelper.ToDbSetMock(itms);
sourceService.Setup(x => x.Orders).Returns(ordersMock.Object);
sourceService.Setup(x => x.Set <DbOrder>()).Returns(ordersMock.Object);
// Action
var result = orderDataService.Get(null, null, null).Result;
var resultId = orderDataService.Get(idForCheck, null, null).Result;
var resultbadId = orderDataService.Get(badIdForCheck, null, null).Result;
var resultDates = orderDataService.Get(null, firstDate, secondDate).Result;
// Assert
ordersMock.Verify(x => x.Where(It.IsAny <Expression <Func <Order, bool> > >()), Times.Exactly(4));
sourceService.Verify(x => x.Set <DbOrder>(), Times.Exactly(4));
Assert.AreEqual(ordersQty, result.Count);
Assert.AreEqual(1, resultId.Count);
Assert.AreEqual(0, resultbadId.Count);
resultDates.ForEach(os =>
{
Assert.IsTrue(os.DateCreated >= firstDate && os.DateCreated < secondDate);
});
}
public void Throws_When_Order_Pies_Are_Missing()
{
var orderTotal = 123;
var userId = "U1";
var orderId = "O1";
var orderAddressCity = "City";
var orderAddressNumber = "+123456778";
var orderAddressStreet = "SampleStreet";
var orderAddressZipCode = "5100";
List <Pie> pies = new List <Pie>();
var orderAddress = new Address()
{
City = orderAddressCity,
Number = orderAddressNumber,
Street = orderAddressStreet,
ZipCode = orderAddressZipCode
};
var order = new Order()
{
Address = orderAddress,
OrderTotal = orderTotal,
Pies = pies,
UserId = userId,
OrderId = orderId
};
var requestProviderMock = new Mock <IRequestProvider>();
requestProviderMock
.Setup(e => e.PostAsync <Order>(It.IsAny <string>(), It.IsAny <Order>(), It.IsAny <string>()))
.Returns(Task.FromResult <Order>(order));
var orderDataService = new OrderDataService(requestProviderMock.Object);
Assert.ThrowsAsync <OrderDataServiceException>(
async() => await orderDataService.AddOrderAsync(order));
}
public void Throws_When_Invalid_Order_Address_Is_Passed()
{
var orderTotal = 123;
var userId = "U1";
var orderId = "O1";
var singlePie = PieListMock
.MockPieCatalog()
.ToList()
.FirstOrDefault();
var pies = new List <Pie>()
{
singlePie
};
Address orderAddress = null;
var order = new Order()
{
Address = orderAddress,
OrderTotal = orderTotal,
Pies = pies,
UserId = userId,
OrderId = orderId
};
var requestProviderMock = new Mock <IRequestProvider>();
requestProviderMock
.Setup(e => e.PostAsync <Order>(It.IsAny <string>(), It.IsAny <Order>(), It.IsAny <string>()))
.Returns(Task.FromResult <Order>(order));
var orderDataService = new OrderDataService(requestProviderMock.Object);
Assert.ThrowsAsync <OrderDataServiceException>(
async() => await orderDataService.AddOrderAsync(order));
}
private async void PlaceOrder(long StoreId, string SlotDate, string SlotTime)
{
var UserId = AppSettings.GetValueOrDefault(Resources.UserId, Resources.DefaultIntValue);
OrderDataService orderData = new OrderDataService();
var formContent = MakeFormContent(UserId, StoreId, SlotDate, SlotTime);
HttpResponseMessage response = await orderData.ServicePlaceOrder(formContent);
var status = response.StatusCode;
string result = await response.Content.ReadAsStringAsync();
if (status == HttpStatusCode.OK)
{
QRText = Slot;
OrderIcon = "OrderSuccess.svg";
Message = Resources.SlotSuccess;
DisplayPopup = false;
}
else
{
OrderIcon = "OrderFailure.svg";
Message = Resources.SlotUnsuccess;
}
}
public async void FillOrders()
{
var orderDs = new OrderDataService();
var rnd = new Random();
var dt = new DateTime(2019, 7, 5);
while (true)
{
dt = dt.AddDays(rnd.Next(3, 8));
if (dt >= DateTime.Now)
{
break;
}
var order = new Order
{
isOrder = true,
report_date = dt,
shop_id = 2,
OrderDetails = new List <OrderDetail>
{
new OrderDetail {
prod_id = 1194, cost = rnd.Next(800, 1200), count = rnd.Next(2, 8)
},
new OrderDetail {
prod_id = 1201, cost = rnd.Next(1750, 2150), count = rnd.Next(2, 5)
},
new OrderDetail {
prod_id = 1212, cost = rnd.Next(2350, 2850), count = rnd.Next(2, 5)
}
}
};
var id = await orderDs.Insert(order);
}
}
public OrderController()
{
var dataService = new Irbis.DataService.Init();
_orderDataService = dataService.OrderDataService;
}
public HttpStatusCode SendMDN(HttpRequest request, int timeoutMs, string signingCertFilename, string signingCertPassword)
{
try
{
string fileData = "This is an automated MDN";
byte[] content = Encoding.ASCII.GetBytes(fileData);
OrderDataService OrderDataServ = new OrderDataService();
AS2CommunicationModel commDetails = OrderDataServ.GetAS2CommunicationDetials(request.Headers["AS2-From"]);
//Initialise the request
HttpWebRequest http = (HttpWebRequest)WebRequest.Create(commDetails.AS2MDNURL);
string recipientPubCertFilename = commDetails.CertificateName;
//Define the standard request objects
http.Method = "POST";
http.AllowAutoRedirect = true;
http.KeepAlive = true;
http.PreAuthenticate = false; //Means there will be two requests sent if Authentication required.
http.SendChunked = false;
//http.UserAgent = "PEERCORE AGENT";
//These Headers are common to all transactions
http.Headers.Add("Mime-Version", "1.0");
http.Headers.Add("AS2-Version", "1.2");
//http.Headers.Add("Date", DateTime.Now.ToString());
http.Headers.Add("AS2-From", request.Headers["AS2-To"]);
http.Headers.Add("AS2-To", request.Headers["AS2-From"]);
http.Headers.Add("Subject", "PO MDN");
http.Headers.Add("Message-Id", request.Headers["Message-Id"] != null? request.Headers["Message-Id"]:"0");
http.Timeout = timeoutMs;
string contentType = "message/disposition-notification";
bool encrypt = !string.IsNullOrEmpty(recipientPubCertFilename);
bool sign = !string.IsNullOrEmpty(signingCertFilename);
if (!sign && !encrypt)
{
http.Headers.Add("Content-Transfer-Encoding", "binary");
http.Headers.Add("Content-Disposition", "inline");
}
if (sign)
{
// Wrap the file data with a mime header
content = AS2MIMEUtilities.CreateMessage(contentType, "binary", "", content);
content = AS2MIMEUtilities.Sign(content, signingCertFilename, signingCertPassword, out contentType);
http.Headers.Add("EDIINT-Features", "multiple-attachments");
}
if (encrypt)
{
string certificateFullPath = "";
if (string.IsNullOrEmpty(recipientPubCertFilename))
{
throw new ArgumentNullException(recipientPubCertFilename, "if encrytionAlgorithm is specified then recipientCertFilename must be specified");
}
else
{
certificateFullPath = ConfigValues.CertificateFilePath + recipientPubCertFilename;
}
byte[] signedContentTypeHeader = System.Text.ASCIIEncoding.ASCII.GetBytes("Content-Type: " + contentType + Environment.NewLine);
byte[] contentWithContentTypeHeaderAdded = AS2MIMEUtilities.ConcatBytes(signedContentTypeHeader, content);
string ba2Str = System.Text.Encoding.Default.GetString(content);
string s1 = System.Text.Encoding.Default.GetString(signedContentTypeHeader);
string s2 = System.Text.Encoding.Default.GetString(contentWithContentTypeHeaderAdded);
content = AS2Encryption.EncryptMDN(contentWithContentTypeHeaderAdded, certificateFullPath, EncryptionAlgorithm.DES3);
// contentType += "multipart/report; report-type=disposition-notification; boundary=\"fredi.boundary.mult.sig.mdn\"; charset=utf-8";
}
http.ContentType += contentType;
http.ContentLength = content.Length;
SendWebRequest(http, content);
return(HandleWebResponse(http));
}
catch (Exception ex)
{
Log.Error($"Exception during sending MDN :: {ex.Message}");
throw;
}
}
public async Task Returns_AddedOrder_When_Correct_Parrameters_Are_Passed()
{
var orderTotal = 123;
var userId = "U1";
var orderId = "O1";
var singlePie = PieListMock
.MockPieCatalog()
.ToList()
.FirstOrDefault();
var orderAddressCity = "AI";
var orderAddressNumber = "+123";
var orderAddressStreet = "Samp";
var orderAddressZipCode = "5100";
var pies = new List <Pie>()
{
singlePie
};
var orderAddress = new Address()
{
City = orderAddressCity,
Number = orderAddressNumber,
Street = orderAddressStreet,
ZipCode = orderAddressZipCode
};
var order = new Order()
{
Address = orderAddress,
OrderTotal = orderTotal,
Pies = pies,
UserId = userId,
OrderId = orderId
};
var requestProviderMock = new Mock <IRequestProvider>();
requestProviderMock
.Setup(e => e.PostAsync <Order>(It.IsAny <string>(), It.IsAny <Order>(), It.IsAny <string>()))
.Returns(Task.FromResult <Order>(order));
var orderDataService = new OrderDataService(requestProviderMock.Object);
var addedOrderResult = await orderDataService.AddOrderAsync(order);
Assert.NotNull(addedOrderResult);
Assert.NotNull(addedOrderResult.Address);
Assert.NotNull(addedOrderResult.Pies);
Assert.AreEqual(addedOrderResult.OrderTotal, orderTotal);
Assert.AreEqual(addedOrderResult.UserId, userId);
Assert.AreEqual(addedOrderResult.OrderId, orderId);
var orderAddedAddress = addedOrderResult.Address;
Assert.AreEqual(orderAddedAddress.City, orderAddressCity);
Assert.AreEqual(orderAddedAddress.Number, orderAddressNumber);
Assert.AreEqual(orderAddedAddress.Street, orderAddressStreet);
Assert.AreEqual(orderAddedAddress.ZipCode, orderAddressZipCode);
var orderAddedPies = addedOrderResult.Pies;
Assert.AreEqual(orderAddedPies.Count, 1);
var orderAddedPie = orderAddedPies.FirstOrDefault();
Assert.AreEqual(orderAddedPie.ImageThumbnailUrl, singlePie.ImageThumbnailUrl);
Assert.AreEqual(orderAddedPie.ImageUrl, singlePie.ImageUrl);
Assert.AreEqual(orderAddedPie.InStock, singlePie.InStock);
Assert.AreEqual(orderAddedPie.IsPieOfTheWeek, singlePie.IsPieOfTheWeek);
Assert.AreEqual(orderAddedPie.LongDescription, singlePie.LongDescription);
Assert.AreEqual(orderAddedPie.Name, singlePie.Name);
Assert.AreEqual(orderAddedPie.PieId, singlePie.PieId);
Assert.AreEqual(orderAddedPie.Price, singlePie.Price);
Assert.AreEqual(orderAddedPie.ShortDescription, singlePie.ShortDescription);
Assert.AreEqual(orderAddedPie.AllergyInformation, singlePie.AllergyInformation);
}
public OrdersController(CnamDbContext context, OrderDataService orderDataService)
{
_orderDataService = orderDataService;
_context = context;
}
/// <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;
}
}
}
public HttpStatusCode SendAcknowledgment(byte[] fileData, string from, string to, ProxySettings proxySettings
, int timeoutMs, string signingCertFilename, string signingCertPassword)
{
try
{
byte[] content = fileData;
OrderDataService OrderDataServ = new OrderDataService();
AS2CommunicationModel commDetails = OrderDataServ.GetAS2CommunicationDetials(to);
// if (commDetails != null)
// {
//Initialise the request
HttpWebRequest http = (HttpWebRequest)WebRequest.Create(commDetails.AS2MDNURL);
string recipientPubCertFilename = commDetails.CertificateName;
if (!String.IsNullOrEmpty(proxySettings.Name))
{
WebProxy proxy = new WebProxy(proxySettings.Name);
NetworkCredential proxyCredential = new NetworkCredential();
proxyCredential.Domain = proxySettings.Domain;
proxyCredential.UserName = proxySettings.Username;
proxyCredential.Password = proxySettings.Password;
proxy.Credentials = proxyCredential;
http.Proxy = proxy;
}
//Define the standard request objects
http.Method = "POST";
http.AllowAutoRedirect = true;
http.KeepAlive = true;
http.PreAuthenticate = false; //Means there will be two requests sent if Authentication required.
http.SendChunked = false;
http.UserAgent = "PEERCORE AGENT";
//These Headers are common to all transactions
http.Headers.Add("Mime-Version", "1.0");
http.Headers.Add("AS2-Version", "1.2");
http.Headers.Add("AS2-From", from);
http.Headers.Add("AS2-To", to);
http.Headers.Add("Subject", "PO Acknowledgment");
http.Headers.Add("Message-Id", "<AS2_" + DateTime.Now.ToString("hhmmssddd") + ">");
http.Timeout = timeoutMs;
string contentType = "application/EDIFACT";
bool encrypt = !string.IsNullOrEmpty(recipientPubCertFilename);
bool sign = !string.IsNullOrEmpty(signingCertFilename);
if (!sign && !encrypt)
{
http.Headers.Add("Content-Transfer-Encoding", "binary");
http.Headers.Add("Content-Disposition", "inline");
}
if (sign)
{
// Wrap the file data with a mime header
content = AS2MIMEUtilities.CreateMessage(contentType, "binary", "", content);
content = AS2MIMEUtilities.Sign(content, signingCertFilename, signingCertPassword, out contentType);
http.Headers.Add("EDIINT-Features", "multiple-attachments");
}
if (encrypt)
{
if (string.IsNullOrEmpty(recipientPubCertFilename))
{
throw new ArgumentNullException(recipientPubCertFilename, "if encrytionAlgorithm is specified then recipientCertFilename must be specified");
}
byte[] signedContentTypeHeader = System.Text.ASCIIEncoding.ASCII.GetBytes("Content-Type: " + contentType + Environment.NewLine);
byte[] contentWithContentTypeHeaderAdded = AS2MIMEUtilities.ConcatBytes(signedContentTypeHeader, content);
string ba2Str = System.Text.Encoding.Default.GetString(content);
string s1 = System.Text.Encoding.Default.GetString(signedContentTypeHeader);
string s2 = System.Text.Encoding.Default.GetString(contentWithContentTypeHeaderAdded);
content = AS2Encryption.Encrypt(contentWithContentTypeHeaderAdded, recipientPubCertFilename, EncryptionAlgorithm.DES3);
if (commDetails.MessageFormat == "SMIME")
{
contentType += "application/pkcs7-mime; smime-type=enveloped-data; name=\"smime.p7m\"";
}
}
http.ContentType += contentType;
http.ContentLength = content.Length;
SendWebRequest(http, content);
return(HandleWebResponse(http));
}
catch (Exception ex)
{
throw;
}
}
