/// <summary>
/// Method for conversions raw order to Cooked order KEKW;
/// Method for processing the Zomato system
/// </summary>
public async Task <PackagedOrder> SystemProccesing(PackagedOrder InputPackagedOrder, ILogRepository iLogRepository, ILogger iLogger)
{
var DeserializatedJsonOrder = Newtonsoft.Json.JsonConvert.DeserializeObject <Order>(InputPackagedOrder.JsonOrder);
try
{
foreach (Product product in DeserializatedJsonOrder.Products)
{
product.paidPrice = product.paidPrice / product.quantity;
}
InputPackagedOrder.OrderNumber = DeserializatedJsonOrder.OrderNumber;
InputPackagedOrder.ConvertedJsonOrder = JsonConvert.SerializeObject(DeserializatedJsonOrder);
}
catch (Exception ERROR)
{
var loger = new Loger(iLogRepository);
await loger.DbExeptionHandler(iLogger, ERROR);
await loger.FileExeptionHandler(ERROR);
}
return(InputPackagedOrder);
}
/// <summary>
/// Insert the Order and OrderProducts into the database.
/// </summary>
/// <param name="packagedOrder">PackagedOrder object received from the Service Bus.</param>
private void InsertPackagedOrder(PackagedOrder packagedOrder)
{
try
{
// Create the database connection and context
// Since it's in a using-block, it will automatically dispose of the connection when it exits the block
using (CS401_DBEntities1 db = new CS401_DBEntities1())
{
var order = packagedOrder.Order;
// Add the order to the db context
db.Orders.Add(order);
// Insert order to get an OrderID
db.SaveChanges();
foreach (var orderProduct in packagedOrder.OrderProducts)
{
orderProduct.OrderId = order.OrderId;
db.OrderProducts.Add(orderProduct);
}
// Insert OrderProducts into database now
db.SaveChanges();
}
}
catch (Exception ex)
{
Trace.WriteLine("Error inserting data into db: " + ex.Message);
SendErrorMessage(ex);
}
}
public async Task <ActionResult> Create([Bind] OrderViewViewModel orderModel)
{
if (ModelState.IsValid)
{
// Unpack data from form and collect the necessary missing data
Order order = new Order();
order.CustomerId = orderModel.CustomerID;
order.CreatedDate = DateTime.Now;
// Get the employee object attached to the logged in user
var currentUser = User.Identity.GetUserId();
var employee = db.Employees.First(emp => emp.AspNetUserID == currentUser);
order.SoldById = employee.EmployeeID;
List <OrderProduct> orderProducts = new List <OrderProduct>();
foreach (int productID in orderModel.ProductID)
{
OrderProduct orderProduct = new OrderProduct();
orderProduct.OrderId = -1;
orderProduct.ProductId = productID;
orderProducts.Add(orderProduct);
}
// Create the PackagedOrder, which will be sent through the Service Bus to the API
PackagedOrder newOrder = new PackagedOrder();
newOrder.Order = order;
newOrder.OrderProducts = orderProducts;
// Handle timezone information. Client will send it in their local time. DateTimeZoneHandling.RoundtripKind maintains the timezone information in the DateTime
// so it can be easily converted to the client's local time later on.
JsonSerializerSettings jsonSettings = new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Include,
DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind
};
// Serialize the PackagedOrder to JSON to send in the Service Bus
string jsonOrder = JsonConvert.SerializeObject(newOrder, jsonSettings);
// Create the message to be sent from the PackagedOrder
var message = new BrokeredMessage(jsonOrder);
// Asynchronously send the message to the Service Bus
await QueueConnector.Client.SendAsync(message);
return(RedirectToAction("Index"));
}
PopulateViewBag(orderModel.ProductID);
return(View(orderModel));
}
/// <summary>
/// Интерфейс ISystem всегда хотел быть стратегией, но что то пошло не так....
/// </summary>
public Task <PackagedOrder> DoProcessing(ISystemStrategy systemStrategy, PackagedOrder InputPackagedOrder, ILogRepository logRepository, ILogger iLogger)
{
if (systemStrategy != null)
{
return(systemStrategy.SystemProccesing(InputPackagedOrder, logRepository, iLogger));
}
else
{
return(null);
}
}
public override void Run()
{
Trace.WriteLine("Starting processing of messages");
// Initiates the message pump and callback is invoked for each message that is received, calling close on the client will stop the pump.
Client.OnMessage((receivedMessage) =>
{
try
{
// Process the message
Trace.WriteLine("Processing Service Bus message: " + receivedMessage.SequenceNumber.ToString());
try
{
// Parse the object from the message
string jsonOrder = receivedMessage.GetBody <string>();
receivedMessage.Complete();
// Handle timezone information. Client will send it in their local time. DateTimeZoneHandling.RoundtripKind maintains the timezone information in the DateTime
// so it can be easily converted to the client's local time later on.
JsonSerializerSettings jsonSettings = new JsonSerializerSettings()
{
DateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind
};
// Deserialize JSON dictionary of PackagedOrder object
PackagedOrder order = JsonConvert.DeserializeObject <PackagedOrder>(jsonOrder);
// Call the method to insert the data into the database
InsertPackagedOrder(order);
}
catch (Exception ex)
{
SendErrorMessage(ex);
}
}
catch
{
// Handle any message processing specific exceptions here
Trace.WriteLine("Error retrieving message: " + receivedMessage.SequenceNumber);
}
});
CompletedEvent.WaitOne();
}
/// <summary>
/// Method for conversions raw order to Cooked order KEKW;
/// Method for processing the Uber system;
/// Try for get Exception
/// </summary>
public async Task <PackagedOrder> SystemProccesing(PackagedOrder InputPackagedOrder, ILogRepository iLogRepository, ILogger iLogger)
{
var DeserializatedJson = Newtonsoft.Json.JsonConvert.DeserializeObject <Order>(InputPackagedOrder.JsonOrder);
InputPackagedOrder.OrderNumber = DeserializatedJson.OrderNumber;
InputPackagedOrder.ConvertedJsonOrder = JsonConvert.SerializeObject(DeserializatedJson);
try
{
throw new Exception("KEKWExeptionActivated(UBER)");
}
catch (Exception ERROR)
{
var loger = new Loger(iLogRepository);
await loger.DbExeptionHandler(iLogger, ERROR);
await loger.FileExeptionHandler(ERROR);
}
return(InputPackagedOrder);
}
/// <summary>
/// This method change element of Order on DataBase
/// </summary>
public void Update(PackagedOrder order)
{
Context.Entry(order).State = EntityState.Modified;
Context.SaveChanges();
}
/// <summary>
/// This method Add element of Order on DataBase
/// </summary>
public async Task Create(PackagedOrder order)
{
Context.PackageOrders.Add(order);
await Context.SaveChangesAsync();
}
