public void WhenMainframeTransactionFails_ThrowsHostTransactionFailureException()
{
// arrange
int WSAECONNRESET = 10054;
MockDependents mockDependents = new MockDependents();
mockDependents.MockOrderSocketConnectionRepository
.Setup(m => m.Receive())
.Throws(BuildMockException(WSAECONNRESET));
IOrderQueueLogic testunit = MakeUnitToBeTested(true, mockDependents);
// act
string jsonOrderFile = GetMockData("OrderFile.json");
OrderFile order = JsonConvert.DeserializeObject <OrderFile>(jsonOrderFile);
Action sendToHost = () => testunit.SendToHost(order);
// assert
sendToHost.Should()
.Throw <HostTransactionFailureException>()
.WithInnerException <SocketResponseException>()
.WithInnerException <IOException>()
.WithMessage("*connection was forcibly closed by the remote host*");
}
public void WhenMainframeDoesNotRespond_ThrowsTimeoutException()
{
// arrange
int WSAETIMEDOUT = 10060;
MockDependents mockDependents = new MockDependents();
mockDependents.MockOrderSocketConnectionRepository
.Setup(m => m.Receive())
.Throws(BuildMockException(WSAETIMEDOUT));
IOrderQueueLogic testunit = MakeUnitToBeTested(true, mockDependents);
// act
string jsonOrderFile = GetMockData("OrderFile.json");
OrderFile order = JsonConvert.DeserializeObject <OrderFile>(jsonOrderFile);
Action sendToHost = () => testunit.SendToHost(order);
// assert
sendToHost.Should()
.Throw <TimeoutException>()
.WithInnerException <SocketResponseException>()
.WithInnerException <IOException>()
.WithMessage("*host has failed to respond*");
}
public void SendToHost(OrderFile order)
{
if (order.Header.OrderType == OrderType.SpecialOrder) // KSOS
{
// Insert to KSOS - RH then RI
_specialOrder.Create(order);
}
else // direct to main frame
{
// open connection and call program
_mfConnection.Connect();
SendStartTransaction(order.Header.ControlNumber.ToString());
// start the order transmission to the mainframe
_mfConnection.Send("OTX");
SendHeaderRecordToHost(order.Header);
SendDetailRecordsToHost(order.Details, order.Header.ControlNumber);
SendEndOfRecordToHost();
// stop order transmission to the mainframe
_mfConnection.Send("STOP");
_mfConnection.Close();
}
}
private void ConsumeMessages()
{
if (Configuration.OrderServiceKDOELogExtension == null)
{
throw new Exception("AppSetting OrderServiceKDOELogExtension is not set.");
}
while (consumingMessages && doListenForMessagesInTask)
{
string msg = ConsumeMessageFromQueue();
if (msg != null)
{
eventLogRepository.WriteInformationLog("Processing from queue. OrderHistory: {QueueMessage}".InjectSingleValue("QueueMessage", msg));
OrderFile order = JsonConvert.DeserializeObject <OrderFile>(msg);
string json = JsonConvert.SerializeObject(order, Formatting.Indented);
System.IO.File.WriteAllText
(Path.Combine(Configuration.OrderServiceKDOELogPath,
string.Format("{0}{1}{2}.{3}", Configuration.OrderServiceKDOELogPre,
order.Header.ControlNumber.ToString("D7"),
Configuration.OrderServiceKDOELogPost,
Configuration.OrderServiceKDOELogExtension)),
json);
}
else
{
consumingMessages = false;
}
}
}
private void accordionControlElement47_Click(object sender, EventArgs e)
{
of = new OrderFile();
of.Show();
of.Dock = DockStyle.Fill;
panel2.Controls.Clear();
panel2.Controls.Add(of);
}
public void WriteOrder(OrderFile orderFile)
{
XmlSerializer xs = new XmlSerializer(typeof(Order));
TextWriter tw = new StreamWriter(@"..\..\LocalData\Orders\" + orderFile.Order.Name + ".ord");
xs.Serialize(tw, orderFile.Order);
tw.Close();
}
public Task AddFile(int orderid)
{
return(Task.Run(() =>
{
var order = _dbcontext.Orders.Where(o => o.Id == orderid).AsNoTracking().FirstOrDefault();
if (order == null)
{
throw new NotFoundException();
}
var file = _httpContextAccessor.HttpContext.Request.Form.Files[0];
Stream stream = file.OpenReadStream();
if (stream.Length > 0)
{
string filePathFull = Path.Combine(_filePath, orderid.ToString()); //Path.GetFileName(file.FileName)
if (!Directory.Exists(filePathFull))
{
Directory.CreateDirectory(filePathFull);
}
string filename = Guid.NewGuid().ToString(); // + Path.GetExtension(file.FileName);
filePathFull = Path.Combine(filePathFull, filename);
using (MemoryStream ms = new MemoryStream())
{
stream.CopyTo(ms);
File.WriteAllBytes(filePathFull, ms.ToArray());
}
try
{
OrderFile orderFile = new OrderFile()
{
Id = 0,
Filename = Path.GetFileName(file.FileName),
OrderId = order.Id,
RepFileName = filename,
userid = _authService.CurrentUserId()
};
_dbcontext.Update(orderFile);
_dbcontext.SaveChanges();
}
catch (Exception ex) {
if (File.Exists(filePathFull))
{
File.Delete(filePathFull);
}
GC.Collect();
throw new Exception("Ошибка загрузки файла");
}
}
}));
}
public void Create(OrderFile file)
{
var query = _specialOrderDbContext.RequestHeaderIds
.SqlQuery("dbo.spGetNextRequestHeaderId @branchId", new SqlParameter("branchId", file.Header.Branch));
string headerId = query.FirstAsync().Result.CurrentId.PadLeft(CONFNUMBER_LENGTH, CONFNUMBER_PADDINGCHAR);
// next, call create after converting OrderFile to RequestHeader
RequestHeader requestHeader = BuildRequestHeader(file.Header, headerId);
_specialOrderDbContext.RequestHeaders.Add(requestHeader);
_specialOrderDbContext.Context.SaveChanges();
foreach (OrderDetail detail in file.Details)
{
_specialOrderDbContext.RequestItems.Add(BuildRequestDetail(detail, headerId, file.Header.Branch, file.Header.CustomerNumber, file.Header.PONumber));
}
_specialOrderDbContext.Context.SaveChanges();
// add idToUse to order history
var orderHistory = _orderHistory.ReadByConfirmationNumber(file.Header.ControlNumber.ToString().PadLeft(CONFNUMBER_LENGTH, CONFNUMBER_PADDINGCHAR), "B").FirstOrDefault();
if (orderHistory == null)
{
// this could only happen if the order was created in Dev and it is being processed in QA
StringBuilder warningMessage = new StringBuilder();
warningMessage.Append("Order not found in order history. This should only happen when created in one environment and processed in another(e.g. Local and Dev). ");
warningMessage.Append("Affected order number is ");
warningMessage.Append(file.Header.ControlNumber);
_log.WriteWarningLog(warningMessage.ToString());
}
else
{
//details
foreach (var orderItem in orderHistory.OrderDetails)
{
var detailItems = file.Details.Where(x => x.ItemNumber == orderItem.ItemNumber.Trim()).ToList();
foreach (var detailItem in detailItems)
{
orderItem.ManufacturerId = detailItem.ManufacturerName;//todo
orderItem.SpecialOrderLineNumber = detailItem.LineNumber.ToString();
orderItem.SpecialOrderHeaderId = headerId;
}
}
_unitOfWork.SaveChangesAndClearContext();
}
requestHeader.OrderStatusId = KSOS_STATUS_SEND;
_specialOrderDbContext.Context.SaveChanges();
}
public InFileOrderRepository()
{
lock (syncroot)
{
lines = File.ReadAllLines(Path);
}
foreach (var item in lines)
{
var order = OrderFile.DeSerialize(item);
orderList.Add(order);
}
}
/// <summary>
/// No duplicated allowed
/// </summary>
/// <param name="newItem"></param>
public void AddItem(OrderFile newItem)
{
//if (_newItems.Select(x => x.Chemical.Name).Contains(newItem.Chemical.Name))
//{
// InventoryItem item = _newItems.First(x => x.Chemical.Name == newItem.Chemical.Name);
// item.QuantityKTWConventional += newItem.QuantityKTWConventional;
// item.QuantitySMWConventional += newItem.QuantitySMWConventional;
// item.QuantityKTWOrganic += newItem.QuantityKTWOrganic;
// item.QuantitySMWOrganic += newItem.QuantitySMWOrganic;
// item.QuantityTKM += newItem.QuantityTKM;
//}
//else
_orders.Add(newItem);
NotifyPropertyChanged("Orders");
}
public void Order_HasValidOrderDate()
{
// arrange
string jsonOrderFile = GetMockData("OrderFile.json");
//expect
string expectedCustomerNumber = "700766";
DateTime expectedOrderdate = new DateTime(2018, 07, 19, 16, 34, 51);
// act
OrderFile orderFile = JsonConvert.DeserializeObject <OrderFile>(jsonOrderFile);
// assert
orderFile.Header.CustomerNumber.Should().Be(expectedCustomerNumber);
orderFile.Header.OrderCreateDateTime.Should().Be(expectedOrderdate);
}
public async Task <long> SaveAsync(SaveOrderFileDto request)
{
var model = new OrderFile
{
FileName = request.FileName,
ReferenceFileName = request.ReferenceFileName,
CreatedById = request.CreatedById,
CreatedOn = request.CreatedOn,
Status = ImportFileStatus.Pending
};
_orderFileRepo.Add(model);
await _orderFileRepo.SaveChangesAsync();
return(model.Id);
}
public void WhenOrderTransmissionIsSuccessful_ExecutesInReasonableTimeSpan()
{
Queue <string> successfulResponseQueue = GetSuccessfulResponseQueue();
MockDependents mockDependents = new MockDependents();
mockDependents.MockOrderSocketConnectionRepository
.Setup(m => m.Receive())
.Returns(() => successfulResponseQueue.Dequeue());
IOrderQueueLogic testunit = MakeUnitToBeTested(true, mockDependents);
// act
string jsonOrderFile = GetMockData("OrderFile.json");
OrderFile order = JsonConvert.DeserializeObject <OrderFile>(jsonOrderFile);
Action sendToHost = () => testunit.SendToHost(order);
// assert
sendToHost.ExecutionTime().Should().BeLessOrEqualTo(TimeSpan.FromMilliseconds(1000));
}
private void ProcessObj(OBJ obj)
{
obj.Processed = true;
OrderFile.Add(obj);
var neighbors =
(
from o in ObjectSet
where o.Processed == false
let dis = Distance.EuclideanDistance(obj.Element, o.Element)
where dis < Epsilon
orderby dis
select o
).ToList();
if (neighbors.Count >= MinPoints)
{
obj.CoreDistance = Distance.EuclideanDistance(obj.Element, neighbors[MinPoints - 1].Element);
UpdateOrderSeeds(neighbors, obj);
}
}
public void WhenOrderTransmissionIsSuccessful_HasNoExceptions()
{
// arrange
Queue <string> successfulResponseQueue = GetSuccessfulResponseQueue();
MockDependents mockDependents = new MockDependents();
mockDependents.MockOrderSocketConnectionRepository
.Setup(m => m.Receive())
.Returns(() => successfulResponseQueue.Dequeue());
IOrderQueueLogic testunit = MakeUnitToBeTested(true, mockDependents);
// act
string jsonOrderFile = GetMockData("OrderFile.json");
OrderFile order = JsonConvert.DeserializeObject <OrderFile>(jsonOrderFile);
Action sendToHost = () => testunit.SendToHost(order);
// assert
sendToHost.Should().NotThrow();
}
public List <OrderFile> getOrders()
{
DirectoryInfo d = new DirectoryInfo(@"..\..\LocalData\Orders");
FileInfo[] files = d.GetFiles("*.ord");
List <OrderFile> orders = new List <OrderFile>();
XmlSerializer xs = new XmlSerializer(typeof(Order));
foreach (FileInfo file in files)
{
string fileLocation = @"..\..\LocalData\Orders\" + file.Name;
FileStream fs = new FileStream(fileLocation, FileMode.Open);
XmlReader reader = XmlReader.Create(fs);
Order i = (Order)xs.Deserialize(reader);
OrderFile orderFile = new OrderFile(i, file);
orders.Add(orderFile);
fs.Close();
}
return(orders);
}
private void WorkOrderQueue(OrderQueueLocation queue)
{
string rawOrder = _orderQueue.ConsumeFromQueue(Configuration.RabbitMQOrderServer, Configuration.RabbitMQUserNameConsumer, Configuration.RabbitMQUserPasswordConsumer, Configuration.RabbitMQVHostOrder, GetSelectedQueue(queue));
while (!string.IsNullOrEmpty(rawOrder))
{
OrderFile order = JsonConvert.DeserializeObject <OrderFile>(rawOrder);
try
{
_log.WriteInformationLog(string.Format("Sending order to mainframe({0})", order.Header.ControlNumber));
SendToHost(order);
SendToHistory(rawOrder);
_log.WriteInformationLog(string.Format("Order sent to mainframe({0})", order.Header.ControlNumber));
}
catch (Exception ex)
{
string errorMessage = string.Format("Error while sending order({0})", order.Header.ControlNumber);
_log.WriteErrorLog(errorMessage, ex);
ExceptionEmail.Send(ex, "", errorMessage);
if (ex is EarlySocketException || ex is CancelledTransactionException)
{
SendToReprocess(rawOrder);
}
else
{
SendToError(ex, rawOrder);
}
throw;
}
rawOrder = _orderQueue.ConsumeFromQueue(Configuration.RabbitMQOrderServer, Configuration.RabbitMQUserNameConsumer, Configuration.RabbitMQUserPasswordConsumer, Configuration.RabbitMQVHostOrder, GetSelectedQueue(queue));
}
}
public void WhenOrderTransmissionIsSuccessful_InvokesReceive()
{
// arrange
Queue <string> successfulResponseQueue = GetSuccessfulResponseQueue();
MockDependents mockDependents = new MockDependents();
mockDependents.MockOrderSocketConnectionRepository
.Setup(m => m.Receive())
.Returns(() => successfulResponseQueue.Dequeue());
IOrderQueueLogic testunit = MakeUnitToBeTested(true, mockDependents);
// act
string jsonOrderFile = GetMockData("OrderFile.json");
OrderFile order = JsonConvert.DeserializeObject <OrderFile>(jsonOrderFile);
Action sendToHost = () => testunit.SendToHost(order);
sendToHost.Invoke();
// assert
mockDependents.MockOrderSocketConnectionRepository
.Verify(m => m.Receive(), Times.Exactly(6), "not called.");
}
public void WriteFileToQueue(string orderingUserEmail, string orderNumber, CS.PurchaseOrder newPurchaseOrder, OrderType orderType, string catalogType, string dsrNumber,
string addressStreet, string addressCity, string addressState, string addressZip)
{
var newOrderFile = new OrderFile()
{
SenderApplicationName = Configuration.ApplicationName,
SenderProcessName = "Send order to queue",
Header = new OrderHeader()
{
OrderingSystem = OrderSource.Entree,
Branch = newPurchaseOrder.Properties["BranchId"].ToString().ToUpper(),
CustomerNumber = newPurchaseOrder.Properties["CustomerId"].ToString(),
DsrNumber = dsrNumber,
AddressStreet = addressStreet,
AddressCity = addressCity,
AddressRegionCode = addressState,
AddressPostalCode = addressZip,
DeliveryDate = newPurchaseOrder.Properties["RequestedShipDate"].ToString(),
PONumber = newPurchaseOrder.Properties["PONumber"] == null ? string.Empty : newPurchaseOrder.Properties["PONumber"].ToString(),
Specialinstructions = string.Empty,
ControlNumber = int.Parse(orderNumber),
OrderType = orderType,
InvoiceNumber = orderType == OrderType.NormalOrder ? string.Empty : (string)newPurchaseOrder.Properties["MasterNumber"],
OrderCreateDateTime = newPurchaseOrder.Properties["DateCreated"].ToString().ToDateTime().Value,
OrderSendDateTime = DateTime.Now.ToLongDateFormatWithTime(),
UserId = orderingUserEmail.ToUpper(),
OrderFilled = false,
FutureOrder = false,
CatalogType = catalogType
},
Details = new List <OrderDetail>()
};
foreach (var lineItem in ((CommerceServer.Foundation.CommerceRelationshipList)newPurchaseOrder.Properties["LineItems"]))
{
var item = (CS.LineItem)lineItem.Target;
if ((orderType == OrderType.ChangeOrder && String.IsNullOrEmpty(item.Status)) ||
orderType == OrderType.DeleteOrder) // do not include line items a) during a change order with no change or b) during a delete order
{
continue;
}
OrderDetail detail = new OrderDetail()
{
ItemNumber = item.ProductId,
OrderedQuantity = (short)item.Quantity,
UnitOfMeasure = ((bool)item.Each ? UnitOfMeasure.Package : UnitOfMeasure.Case),
SellPrice = (double)item.PlacedPrice,
Catchweight = (bool)item.CatchWeight,
LineNumber = Convert.ToInt16(lineItem.Target.Properties["LinePosition"]),
SubOriginalItemNumber = string.Empty,
ReplacedOriginalItemNumber = string.Empty,
Description = item.DisplayName,
ManufacturerName = item.Notes,
UnitCost = (decimal)item.ListPrice
};
if (orderType == OrderType.ChangeOrder)
{
switch (item.Status)
{
case "added":
detail.ItemChange = LineType.Add;
break;
case "changed":
detail.ItemChange = LineType.Change;
break;
case "deleted":
detail.ItemChange = LineType.Delete;
break;
default:
detail.ItemChange = LineType.NoChange;
break;
}
}
newOrderFile.Details.Add(detail);
}
_log.WriteInformationLog(string.Format("Writing order to queue: {0}", JsonConvert.SerializeObject(newOrderFile)));
_orderQueue.PublishToQueue(JsonConvert.SerializeObject(newOrderFile), Configuration.RabbitMQOrderServer, Configuration.RabbitMQUserNamePublisher, Configuration.RabbitMQUserPasswordPublisher, Configuration.RabbitMQVHostOrder, GetSelectedExchange(OrderQueueLocation.Normal));
//set order status ID to 5
}
