static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MessageBodyEncryption.Endpoint1");
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.RegisterMessageEncryptor();
busConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(busConfiguration);
try
{
IBusSession busSession = endpoint.CreateBusSession();
CompleteOrder completeOrder = new CompleteOrder
{
CreditCard = "123-456-789"
};
await busSession.Send("Samples.MessageBodyEncryption.Endpoint2", completeOrder);
Console.WriteLine("Message sent");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static void Main()
{
Configure configure = Configure.With();
configure.Log4Net();
configure.DefineEndpointName("Samples.MessageBodyEncryption.Endpoint1");
configure.DefaultBuilder();
configure.RijndaelEncryptionService();
configure.MsmqTransport();
configure.InMemorySagaPersister();
configure.RunTimeoutManagerWithInMemoryPersistence();
configure.InMemorySubscriptionStorage();
configure.JsonSerializer();
#region RegisterMessageEncryptor
configure.RegisterMessageEncryptor();
#endregion
using (IStartableBus startableBus = configure.UnicastBus().CreateBus())
{
IBus bus = startableBus.Start(() => configure.ForInstallationOn<Windows>().Install());
CompleteOrder completeOrder = new CompleteOrder
{
CreditCard = "123-456-789"
};
bus.Send("Samples.MessageBodyEncryption.Endpoint2", completeOrder);
Console.WriteLine("Message sent.");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
static void Main()
{
Console.Title = "Samples.MessageBodyEncryption.Endpoint1";
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MessageBodyEncryption.Endpoint1");
busConfiguration.UsePersistence<InMemoryPersistence>();
#region RegisterMessageEncryptor
busConfiguration.RegisterMessageEncryptor();
#endregion
var startableBus = Bus.Create(busConfiguration);
using (var bus = startableBus.Start())
{
var completeOrder = new CompleteOrder
{
CreditCard = "123-456-789"
};
bus.Send("Samples.MessageBodyEncryption.Endpoint2", completeOrder);
Console.WriteLine("Message sent");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
static void Main()
{
Console.Title = "Samples.MessageBodyEncryption.Endpoint1";
Configure.Serialization.Json();
var configure = Configure.With();
configure.Log4Net();
configure.DefineEndpointName("Samples.MessageBodyEncryption.Endpoint1");
configure.DefaultBuilder();
configure.UseTransport<Msmq>();
configure.InMemorySagaPersister();
configure.UseInMemoryTimeoutPersister();
configure.InMemorySubscriptionStorage();
#region RegisterMessageEncryptor
configure.RegisterMessageEncryptor();
#endregion
using (var startableBus = configure.UnicastBus().CreateBus())
{
var bus = startableBus.Start(() => configure.ForInstallationOn<Windows>().Install());
var completeOrder = new CompleteOrder
{
CreditCard = "123-456-789"
};
bus.Send("Samples.MessageBodyEncryption.Endpoint2", completeOrder);
Console.WriteLine("Message sent");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
static async Task AsyncMain()
{
Console.Title = "Samples.MessageBodyEncryption.Endpoint2";
EndpointConfiguration endpointConfiguration = new EndpointConfiguration("Samples.MessageBodyEncryption.Endpoint1");
endpointConfiguration.UsePersistence<InMemoryPersistence>();
#region RegisterMessageEncryptor
endpointConfiguration.RegisterMessageEncryptor();
#endregion
endpointConfiguration.SendFailedMessagesTo("error");
IEndpointInstance endpoint = await Endpoint.Start(endpointConfiguration);
try
{
CompleteOrder completeOrder = new CompleteOrder
{
CreditCard = "123-456-789"
};
await endpoint.Send("Samples.MessageBodyEncryption.Endpoint2", completeOrder);
Console.WriteLine("Message sent");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
finally
{
await endpoint.Stop();
}
}
static async Task AsyncMain()
{
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.MessageBodyEncryption.Endpoint1");
busConfiguration.UsePersistence<InMemoryPersistence>();
busConfiguration.RegisterMessageEncryptor();
busConfiguration.SendFailedMessagesTo("error");
IStartableBus startableBus = Bus.Create(busConfiguration);
using (IBus bus = await startableBus.StartAsync())
{
CompleteOrder completeOrder = new CompleteOrder
{
CreditCard = "123-456-789"
};
await bus.SendAsync("Samples.MessageBodyEncryption.Endpoint2", completeOrder);
Console.WriteLine("Message sent");
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
public void Handle(CompleteOrder message)
{
// code to handle order completion
MarkAsComplete();
}
public Task Handle(CompleteOrder message, IMessageHandlerContext context)
{
log.Info($"CompleteOrder received with OrderId {message.OrderId}");
MarkAsComplete();
return(Task.CompletedTask);
}
public void Handle(CompleteOrder message)
{
log.Info($"Saga with OrderId {Data.OrderId} received CompleteOrder with OrderId {message.OrderId}");
MarkAsComplete();
}
//----------------------------- Cancel Order ----------------------------------------------//
public async Task <ApiResponse <string> > CancelOrder(string orderId)
{
//Cancel Order: remove order from queue, set next order (if found) time to current time and adjust queue.
ApiResponse <string> result = new ApiResponse <string>();
try
{
var order = await unitOfWork.OrdersManager.GetAsync(b => b.Id == Int32.Parse(orderId), 0, 0, null, includeProperties : "OrderServices");
Order OrderToUpdate = order.FirstOrDefault();
if (OrderToUpdate != null)
{
var customer = await unitOfWork.CustomersManager.GetByIdAsync(OrderToUpdate.CustomerId);
var barberQueue = await unitOfWork.BarbersQueuesManager.GetByIdAsync(OrderToUpdate.BarberQueueId);
var barber = await unitOfWork.BarbersManager.GetByIdAsync(barberQueue.BarberId);
CompleteOrder completeOrder = new CompleteOrder();
completeOrder.OrderTotalAmount = completeOrder.OrderTotalAmount - (completeOrder.OrderTotalAmount * (OrderToUpdate.DiscountRate / 100));
completeOrder.OrderServicesList = "";
completeOrder.BarberId = barber.Id;
completeOrder.OrderDateTime = OrderToUpdate.OrderDate;
completeOrder.OrderFinishTime = OrderToUpdate.FinishTime;
completeOrder.CustomerId = customer.Id;
completeOrder.CustomerNameEN = customer.Name;
completeOrder.CustomerNameAR = customer.Name;
completeOrder.BarberNameAR = barber.NameAR;
completeOrder.BarberNameEN = barber.NameEN;
completeOrder.CustomerWaitingTimeInMinutes = OrderToUpdate.WaitingTimeInMinutes;
completeOrder.Status = "Canceled";
completeOrder.TotalTimeSpent = OrderToUpdate.TotalServicesWaitingTime;
completeOrder.OrderTotalAmount = 0;
for (int i = 0; i < order.FirstOrDefault().OrderServices.Count; i++)
{
completeOrder.OrderTotalAmount += order.FirstOrDefault().OrderServices[i].Price;
}
for (int i = 0; i < order.FirstOrDefault().OrderServices.Count; i++)
{
completeOrder.OrderServicesList = completeOrder.OrderServicesList + order.FirstOrDefault().OrderServices[i].ServiceId + ",";
}
List <ServicesToRecord> GoogleSheetServiceList = new List <ServicesToRecord>();
for (int i = 0; i < order.FirstOrDefault().OrderServices.Count; i++)
{
ServicesToRecord GoogleSheetServiceItem = new ServicesToRecord();
GoogleSheetServiceItem.ServiceNameAR = order.FirstOrDefault().OrderServices[i].NameAR;
GoogleSheetServiceItem.ServiceNameEN = order.FirstOrDefault().OrderServices[i].NameEN;
GoogleSheetServiceItem.ServiceTime = order.FirstOrDefault().OrderServices[i].Time;
GoogleSheetServiceItem.ServicePrice = order.FirstOrDefault().OrderServices[i].Price;
GoogleSheetServiceItem.ServiceStatus = order.FirstOrDefault().OrderServices[i].IsConfirmed;
GoogleSheetServiceList.Add(GoogleSheetServiceItem);
}
var info = TimeZoneInfo.FindSystemTimeZoneById("Egypt Standard Time");
DateTimeOffset localServerTime = DateTimeOffset.Now;
DateTimeOffset localTime = TimeZoneInfo.ConvertTime(localServerTime, info);
OrderToRecord GoogleSheetOrder = new OrderToRecord();
GoogleSheetOrder.BarberNameAR = completeOrder.BarberNameAR;
GoogleSheetOrder.BarberNameEN = completeOrder.BarberNameEN;
GoogleSheetOrder.CustomerNameAR = completeOrder.CustomerNameAR;
GoogleSheetOrder.CustomerNameEN = completeOrder.CustomerNameEN;
GoogleSheetOrder.DiscountRate = order.FirstOrDefault().DiscountRate;
GoogleSheetOrder.OrderTotalAmount = completeOrder.OrderTotalAmount;
GoogleSheetOrder.OrderEndTime = localTime.DateTime;
GoogleSheetOrder.OrderStartTime = order.FirstOrDefault().OrderDate;
GoogleSheetOrder.DiscountPrice = 0;
GoogleSheetOrder.Services = GoogleSheetServiceList;
AddOrderToGoogleSheets(GoogleSheetOrder);
//Fetch barber queue from order.
var barberQueueToFetch = await unitOfWork.BarbersQueuesManager.GetAsync(q => q.Id == OrderToUpdate.BarberQueueId, includeProperties : "Orders");
var queue = barberQueueToFetch.FirstOrDefault();
if (queue != null)
{
//Fetch and remove order to remove from Queue order list
var orderToRemove = queue.Orders.Find(o => o.Id == Int32.Parse(orderId));
queue.Orders.Remove(orderToRemove);
for (int i = 0; i < queue.Orders.Count; i++) // Update upcoming orders
{
if (i == 0)
{
queue.Orders[i].OrderDate = DateTime.Now;
queue.Orders[i].FinishTime = queue.Orders[i].OrderDate.Value.AddMinutes(Convert.ToDouble(queue.Orders[i].TotalServicesWaitingTime));
}
else
{
queue.Orders[i].OrderDate = queue.Orders[i - 1].FinishTime;
queue.Orders[i].FinishTime = queue.Orders[i].OrderDate.Value.AddMinutes(Convert.ToDouble(queue.Orders[i].TotalServicesWaitingTime));
}
}
await unitOfWork.SaveChangesAsync();
result.Data = "Order cancelled successfully.";
result.Succeeded = true;
return(result);
}
else
{
result.Succeeded = false;
result.Errors.Add("Could not fetch barber queue");
return(result);
}
}
else
{
result.Data = "Error";
result.Succeeded = false;
result.Errors.Add("Could not fetch order service");
return(result);
}
}
catch (Exception ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
return(result);
}
}
//--------------------------------- Finalize Order ------------------------------------------------//
public async Task <ApiResponse <string> > FinalizeOrder(int orderId)
{
ApiResponse <string> result = new ApiResponse <string>();
try
{
var orderToFetch = await unitOfWork.OrdersManager.GetAsync(o => o.Id == orderId, includeProperties : "OrderServices");
var order = orderToFetch.FirstOrDefault();
var orderToFinalize = new Order();
var orderToExcelExtract = order;
float totalAmountToExtract = 0;
var SMS = new SmsService(unitOfWork, config);
SendSMSDTO sendSMS = new SendSMSDTO();
sendSMS.CustomerNumber = order.CustomerMobile;
sendSMS.orderId = orderId;
if (sendSMS.CustomerNumber != null)
{
// var SendSMS = await SMS.SendSMS(sendSMS);
}
if (order != null)
{
CompleteOrder completeOrder = new CompleteOrder();
completeOrder.OrderServicesList = "";
orderToFinalize.OrderServices = order.OrderServices.Where(o => o.IsConfirmed == true).ToList(); // Filter confirmed services.
//Fetch customer and barber from order.
var customer = await unitOfWork.CustomersManager.GetByIdAsync(order.CustomerId);
var barberQueue = await unitOfWork.BarbersQueuesManager.GetByIdAsync(order.BarberQueueId);
var barber = await unitOfWork.BarbersManager.GetByIdAsync(barberQueue.BarberId);
//Create complete Order
completeOrder.OrderTotalAmount = 0;
for (int i = 0; i < orderToFinalize.OrderServices.Count; i++)
{
completeOrder.OrderTotalAmount += orderToFinalize.OrderServices[i].Price;
}
totalAmountToExtract = (float)completeOrder.OrderTotalAmount;
completeOrder.OrderTotalAmount = completeOrder.OrderTotalAmount - (completeOrder.OrderTotalAmount * (order.DiscountRate / 100));
completeOrder.BarberId = barber.Id;
completeOrder.OrderDateTime = order.OrderDate;
completeOrder.OrderFinishTime = order.FinishTime;
completeOrder.CustomerId = customer.Id;
completeOrder.CustomerNameEN = customer.Name;
completeOrder.CustomerNameAR = customer.Name;
completeOrder.BarberNameAR = barber.NameAR;
completeOrder.BarberNameEN = barber.NameEN;
completeOrder.CustomerWaitingTimeInMinutes = order.WaitingTimeInMinutes;
completeOrder.Status = "Finalized";
completeOrder.TotalTimeSpent = order.TotalServicesWaitingTime;
//Fill complete order services list
List <OrderService> orderServicesHistory = new List <OrderService>();
orderServicesHistory = orderToFinalize.OrderServices;
List <ServicesToRecord> GoogleSheetServiceList = new List <ServicesToRecord>();
for (int i = 0; i < order.OrderServices.Count; i++)
{
completeOrder.OrderServicesList = completeOrder.OrderServicesList + order.OrderServices[i].ServiceId + ",";
}
//construct the list of the excel
for (int i = 0; i < orderToExcelExtract.OrderServices.Count; i++)
{
ServicesToRecord GoogleSheetServiceItem = new ServicesToRecord();
GoogleSheetServiceItem.ServiceNameAR = orderToExcelExtract.OrderServices[i].NameAR;
GoogleSheetServiceItem.ServiceNameEN = orderToExcelExtract.OrderServices[i].NameEN;
GoogleSheetServiceItem.ServiceTime = orderToExcelExtract.OrderServices[i].Time;
GoogleSheetServiceItem.ServicePrice = orderToExcelExtract.OrderServices[i].Price;
GoogleSheetServiceItem.ServiceStatus = orderToExcelExtract.OrderServices[i].IsConfirmed;
GoogleSheetServiceList.Add(GoogleSheetServiceItem);
}
//Create complete order
var completeOrderCreationResult = await unitOfWork.CompleteOrdersManager.CreateAsync(completeOrder);
barber.NumberOfCustomersHandled++; // Increase barber # of customers handled counter
await unitOfWork.OrdersManager.RemoveAsync(order); // Remove order record.
await unitOfWork.SaveChangesAsync();
// Update upcoming orders
var queueResult = await unitOfWork.BarbersQueuesManager.GetAsync(q => q.Id == order.BarberQueueId, includeProperties : "Orders");
var queue = queueResult.FirstOrDefault();
for (int i = 0; i < queue.Orders.Count; i++)
{
if (i == 0)
{
queue.Orders[i].OrderDate = DateTime.Now;
queue.Orders[i].FinishTime = queue.Orders[i].OrderDate.Value.AddMinutes(Convert.ToDouble(queue.Orders[i].TotalServicesWaitingTime));
}
else
{
queue.Orders[i].OrderDate = queue.Orders[i - 1].FinishTime;
queue.Orders[i].FinishTime = queue.Orders[i].OrderDate.Value.AddMinutes(Convert.ToDouble(queue.Orders[i].TotalServicesWaitingTime));
}
}
await unitOfWork.SaveChangesAsync();
//Create order feedback
OrderFeedback orderFeedback = new OrderFeedback();
orderFeedback.IsSubmitted = false;
orderFeedback.CompleteOrderId = completeOrderCreationResult.Id;
var orderFeedbackCreationResult = await unitOfWork.OrderFeedBacksManager.CreateAsync(orderFeedback);
await unitOfWork.SaveChangesAsync();
//Create Orderfeedback questions
for (int i = 0; i < orderServicesHistory.Count; i++)
{
var serviceFeedbackQuestionsResult = await unitOfWork.ServiceFeedBackQuestionsManager.GetAsync(s => s.ServiceId == orderServicesHistory[i].ServiceId);
var serviceFeedbackQuestionsList = serviceFeedbackQuestionsResult.ToList();
for (int j = 0; j < serviceFeedbackQuestionsList.Count; j++)
{
OrderFeedbackQuestion orderFeedbackQuestionToCreate = new OrderFeedbackQuestion();
orderFeedbackQuestionToCreate.OrderFeedbackId = orderFeedbackCreationResult.Id;
orderFeedbackQuestionToCreate.QuestionAR = serviceFeedbackQuestionsList[j].QuestionAR;
orderFeedbackQuestionToCreate.QuestionEN = serviceFeedbackQuestionsList[j].QuestionEN;
orderFeedbackQuestionToCreate.Rating = 0;
var FeedbackQuestionCreationResult = await unitOfWork.OrderFeedBackQuestionsManager.CreateAsync(orderFeedbackQuestionToCreate);
await unitOfWork.SaveChangesAsync();
}
}
//gets the egypt time to get the final time
var info = TimeZoneInfo.FindSystemTimeZoneById("Egypt Standard Time");
DateTimeOffset localServerTime = DateTimeOffset.Now;
DateTimeOffset localTime = TimeZoneInfo.ConvertTime(localServerTime, info);
//var googleSheetsRecordResult = await AddOrderToGoogleSheets(completeOrder);
OrderToRecord GoogleSheetOrder = new OrderToRecord();
GoogleSheetOrder.BarberNameAR = completeOrder.BarberNameAR;
GoogleSheetOrder.BarberNameEN = completeOrder.BarberNameEN;
GoogleSheetOrder.CustomerNameAR = completeOrder.CustomerNameAR;
GoogleSheetOrder.CustomerNameEN = completeOrder.CustomerNameEN;
GoogleSheetOrder.DiscountRate = orderToExcelExtract.DiscountRate;
GoogleSheetOrder.OrderTotalAmount = totalAmountToExtract;
GoogleSheetOrder.OrderEndTime = localTime.DateTime;
GoogleSheetOrder.OrderStartTime = orderToExcelExtract.OrderDate;
GoogleSheetOrder.DiscountPrice = totalAmountToExtract - completeOrder.OrderTotalAmount;
GoogleSheetOrder.Services = GoogleSheetServiceList;
AddOrderToGoogleSheets(GoogleSheetOrder); // Save order history in google spreadsheet
result.Succeeded = true;
result.Data = "Finalized successfully";
return(result);
}
else
{
result.Errors.Add("Failed to fetch order");
result.Succeeded = false;
return(result);
}
}
catch (Exception ex)
{
result.Succeeded = false;
result.Errors.Add(ex.Message);
return(result);
}
}
public async Task HandleMessageAsync(CompleteOrder message, CancellationToken cancellationToken)
{
_store.UpdateOrder(new Order(message.Id, OrderState.Completed));
await _mediator.SendMessageAsync(new Notify("Order completed."), cancellationToken);
}
public async Task HandleAsync(CompleteOrder command)
{
await ExecuteAsync(command.OrderId, order => order.CompleteOrder());
}
public Task Handle(CompleteOrder message, IMessageHandlerContext context)
{
logger.InfoFormat("OrderSagaAttributes with OrderId {0} received CompleteOrder with OrderId {1}", Data.OrderId, message.OrderId);
MarkAsComplete();
return(Task.FromResult(0));
}
public async Task <IActionResult> Complete(
[FromServices] Func <CompleteOrder, CompleteOrderContext> factory,
[FromBody] CompleteOrder command) =>
await this.ProcessAsync(factory(command));
public void Handle(CompleteOrder message)
{
logger.InfoFormat("OrderSagaLoquacious with OrderId {0} received CompleteOrder with OrderId {1}", Data.OrderId, message.OrderId);
MarkAsComplete();
}
public Task Handle(CompleteOrder message, IMessageHandlerContext context)
{
log.Info($"OrderSagaLoquacious with OrderId {Data.OrderId} received CompleteOrder with OrderId {message.OrderId}");
MarkAsComplete();
return(Task.FromResult(0));
}
public Task Handle(CompleteOrder message, IMessageHandlerContext context)
{
log.Info($"OrderSagaAttributes with OrderId {Data.OrderId} received CompleteOrder with OrderId {message.OrderId}");
MarkAsComplete();
return(Task.CompletedTask);
}
public Task <OrderSagaData> FindBy(CompleteOrder message, SynchronizedStorageSession storageSession, ReadOnlyContextBag context)
{
var session = storageSession.RavenSession();
return(session.LoadByUniqueConstraintAsync <OrderSagaData>(d => d.OrderId, message.OrderId));
}
public Task Handle(PackageWasSent @event, CancellationToken cancellationToken)
{
return(commandBus.Send(CompleteOrder.Create(@event.OrderId)));
}
static void Main(string[] args)
{
// Seed the database if none exists
dbUtilities db = new dbUtilities("BANGAZONCLI_DB");
CustomerManager cm = new CustomerManager(db);
PaymentTypeManager paytm = new PaymentTypeManager(db);
db.CheckCustomer();
db.CheckPaymentType();
db.CheckOrder();
db.CheckProductType();
db.CheckProduct();
db.CheckProductOrder();
db.SeedTables();
MainMenu menu = new MainMenu();
ProductManager pm = new ProductManager(db);
ProductTypeManager ptm = new ProductTypeManager(db);
OrderManager om = new OrderManager(db);
int choice;
do
{
// Show the Main Menu
choice = menu.ShowMainMenu();
switch (choice)
{
case 1:
// Displays the Create Customer Menu
CreateCustomer.CreateCustomerMenu(cm);
break;
case 2:
ChooseCustomer.ChooseCustomerMenu(cm, db);
break;
case 3:
if (CustomerManager.currentCustomer == null)
{
ChooseCustomer.ChooseCustomerMenu(cm, db);
}
CreatePayment.CreatePaymentMenu(paytm);
break;
case 4:
if (CustomerManager.currentCustomer == null)
{
ChooseCustomer.ChooseCustomerMenu(cm, db);
}
AddProductToSell.DoAction(pm, ptm);
break;
case 5:
if (CustomerManager.currentCustomer == null)
{
ChooseCustomer.ChooseCustomerMenu(cm, db);
}
AddProductOrder.AddProductToOrder(cm, pm, om);
break;
case 6:
if (CustomerManager.currentCustomer == null)
{
ChooseCustomer.ChooseCustomerMenu(cm, db);
}
CompleteOrder.CompleteOrderMenu(om, pm, paytm);
break;
case 7:
if (CustomerManager.currentCustomer == null)
{
ChooseCustomer.ChooseCustomerMenu(cm, db);
}
RemoveProductToSell.RemoveProductToSellMenu(pm);
break;
case 8:
if (CustomerManager.currentCustomer == null)
{
ChooseCustomer.ChooseCustomerMenu(cm, db);
}
UpdateProduct.UpdateProductMenu(pm);
break;
case 9:
if (CustomerManager.currentCustomer == null)
{
ChooseCustomer.ChooseCustomerMenu(cm, db);
}
ShowStale.DoAction(om);
break;
case 10:
if (CustomerManager.currentCustomer == null)
{
ChooseCustomer.ChooseCustomerMenu(cm, db);
}
RevenueReport.ShowRevenueReport(om);
break;
case 11:
ProductPopularityReport.ProductPopularityReportMenu(pm);
break;
}
} while(choice != 12);
}
public async Task <ActionResult> CreateOrderComplete(CompleteOrder orderComplete)
{
try
{
//if (ModelState.IsValid)
//{
Order master = new Order
{
PatientLastName = Empty,
Age = orderComplete.OrderMaster.Age > 0 ? orderComplete.OrderMaster.Age : -1,
Coupon =
!IsNullOrWhiteSpace(orderComplete.OrderMaster.Coupon) ? orderComplete.OrderMaster.Coupon : Empty,
DateCreation =
!IsNullOrWhiteSpace(orderComplete.OrderMaster.DateCreation)
? orderComplete.OrderMaster.DateCreation
: DateTime.Now.Date.ToShortDateString(),
DateDelivery = orderComplete.OrderMaster.DateDelivery,
Gender =
!IsNullOrWhiteSpace(orderComplete.OrderMaster.Gender)
? orderComplete.OrderMaster.Gender
: string.Empty,
IdClient = orderComplete.OrderMaster.IdClient,
Location =
!IsNullOrWhiteSpace(orderComplete.OrderMaster.Location)
? orderComplete.OrderMaster.Location
: string.Empty,
Name =
Format("{0}-{1}", orderComplete.OrderMaster.PatientName,
orderComplete.OrderMaster.DateCreation),
PatientName = orderComplete.OrderMaster.PatientName,
Price =
IsNullOrWhiteSpace(orderComplete.OrderMaster.Price.ToString()) ? 0 : orderComplete.OrderMaster.Price,
PriceTax =
IsNullOrWhiteSpace(orderComplete.OrderMaster.PriceTax.ToString())
? 0
: orderComplete.OrderMaster.PriceTax,
PriceTotal =
IsNullOrWhiteSpace(orderComplete.OrderMaster.PriceTotal.ToString())
? 0
: orderComplete.OrderMaster.PriceTotal,
Score =
IsNullOrWhiteSpace(orderComplete.OrderMaster.Score.ToString())
? -1
: orderComplete.OrderMaster.Score
};
//db.Orders.Add(master);
//db.SaveChanges();
foreach (DetailOrder item in orderComplete.OrderDetail)
{
item.IdOrder = master.ID;
//item.AbutmentsParallel = IsNullOrWhiteSpace(item.AbutmentsParallel) ? Empty : item.AbutmentsParallel;
//item.Amount = IsNullOrWhiteSpace(item.Amount.ToString()) ? 0 : item.Amount;
//item.ArticulatorType = IsNullOrWhiteSpace(item.ArticulatorType) ? Empty : item.ArticulatorType;
//item.BuccalMargin = IsNullOrWhiteSpace(item.BuccalMargin) ? Empty : item.BuccalMargin;
//item.BuccalTissueCompression = IsNullOrWhiteSpace(item.BuccalTissueCompression) ? Empty : item.BuccalTissueCompression;
//item.Contact = IsNullOrWhiteSpace(item.Contact) ? Empty : item.Contact;
//item.DesignRequirements = IsNullOrWhiteSpace(item.DesignRequirements) ? Empty : item.DesignRequirements;
//item.AbutmentsParallel = IsNullOrWhiteSpace(item.AbutmentsParallel) ? Empty : item.AbutmentsParallel;
//item.Teeth = IsNullOrWhiteSpace(item.Teeth) ? Empty : item.Teeth;
//item.Shade = IsNullOrWhiteSpace(item.Shade) ? Empty : item.Shade;
//item.Note = IsNullOrWhiteSpace(item.Note) ? Empty : item.Note;
//item.LingualMargin = IsNullOrWhiteSpace(item.LingualMargin) ? Empty : item.LingualMargin;
//item.LingualTissueCompression = IsNullOrWhiteSpace(item.LingualTissueCompression) ? Empty : item.LingualTissueCompression;
//item.Oclussion = IsNullOrWhiteSpace(item.Oclussion) ? Empty : item.Oclussion;
//item.ModelServices = IsNullOrWhiteSpace(item.ModelServices) ? Empty : item.ModelServices;
//item.Material = IsNullOrWhiteSpace(item.Material) ? Empty : item.Material;
//item.IdName = IsNullOrWhiteSpace(item.IdName) ? Empty : item.IdName;
master.DetailOrders.Add(item);
}
db.Orders.AddOrUpdate(master);
db.SaveChanges();
//foreach (Attachment item in order.ListAtaAttachments)
//{
// Attachment objtAttachment = new Attachment();
// objtAttachment.Format = item.Format;
// objtAttachment.Name = item.Name;
// objtAttachment.NameUpdated = item.NameUpdated;
// objtAttachment.SizeFile = item.SizeFile;
// objtAttachment.kindFile = item.kindFile;
// objtAttachment.IdOrder = Master.ID;
// db.Attachments.Add(objtAttachment);
//}
//await db.SaveChangesAsync();
//return RedirectToAction("Index");
//}
//ViewBag.IdClient = new SelectList(db.Clients, "ID", "Name", order.OrderMaster.IdClient);
return(View(orderComplete));
}
catch (Exception ex)
{
var x = ex.Message;
throw;
}
}
public Task Handle(CompleteOrder message, IMessageHandlerContext context)
{
// code to handle order completion
MarkAsComplete();
return(Task.CompletedTask);
}
public async Task <IActionResult> Complete(Guid id, CompleteOrder command)
=> await SendAsync(command.Bind(c => c.Id, id).Bind(c => c.CustomerId, UserId),
resourceId : command.Id, resource : "orders");
static void Main(string[] args)
{
CreateAnAccount createAnAccount = new CreateAnAccount();
GetCustomerList getCustomerList = new GetCustomerList();
CreatePayment createPayment = new CreatePayment();
AddProductToOrder addProduct = new AddProductToOrder();
CompleteOrder completeOrder = new CompleteOrder();
Console.WriteLine(@"
**************************
********************************
************ SHUFFLEPUFF ***********
************* BANGAZON *************
********************************
**************************"
);
START:
Console.WriteLine(@" 1. Create an Account" + Environment.NewLine + " 2. Choose Active Customer" + Environment.NewLine + " 3. Create Payment Option" + Environment.NewLine + " 4. Search for Products" + Environment.NewLine + " 5. Complete Order" + Environment.NewLine + " 6. See Product Popularity" + Environment.NewLine + " 7. Leave Shufflepuff Bangazon"
);
string userCommand = Console.ReadKey(true).KeyChar.ToString();
switch (userCommand)
{
case "1":
Console.Clear();
var savedToDatabase = createAnAccount.CreateNewAccount();
Debug.WriteLine(savedToDatabase);
Console.Clear();
goto START;
case "2":
Console.WriteLine("Choose Active Customer");
getCustomerList.DisplayCustomerList();
Console.Clear();
goto START;
case "3":
Console.Clear();
var paymentSavedToDatabase = createPayment.SelectPaymentType();
Debug.WriteLine(paymentSavedToDatabase);
Console.Clear();
goto START;
case "4":
Console.WriteLine("Choose Product");
addProduct.DisplayProductList();
Console.Clear();
//Console.WriteLine(addProduct.SelectedProductId);
List <Product> productIdList = addProduct.GetProducts();
foreach (Product item in productIdList)
{
Console.WriteLine(item);
}
Console.ReadLine();
goto START;
////product search
//ProductRepo repo = new ProductRepo();
//var products = repo.GetProducts();
//foreach (Product product in products)
//{
// Console.WriteLine(product.ProductId + ". " + product.Name + " " + product.Price);
//}
//break;
case "5":
//complete order
if (completeOrder.DetermineIfOrderContainsProducts())
{
if (completeOrder.DetermineIfReadyToPurchase())
{
completeOrder.ChoosePaymentMethod();
}
}
else
{
Console.WriteLine("Please add products to your order. Press any key to continue.");
Console.Clear();
}
goto START;
case "6":
//product popularity
PaymentRepo repo = new PaymentRepo();
var payments = repo.GetPayments(getCustomerList.GetSelectedUserId());
foreach (var payment in payments)
{
Console.WriteLine(payment.Type + ". " + payment.AccountNumber);
}
goto START;
case "7":
Console.WriteLine("See Ya!");
Environment.Exit(0);
break;
default:
Console.WriteLine("Please select a valid option...");
break;
}
}
public OrderSagaData FindBy(CompleteOrder message)
{
var session = sessionProvider.Session;
return(session.LoadByUniqueConstraint <OrderSagaData>(d => d.OrderId, message.OrderId));
}
public static BaseOrder CreateBaseOrder(CompleteOrder completeOrder)
{
return(CreateBaseOrder(completeOrder.User, completeOrder.ShipmentInfo, completeOrder.OrderProcessingStatus,
completeOrder.OrderId, completeOrder.OrderDate, completeOrder.TotalPrice()));
}
public async Task Handle(CompleteOrder message, IMessageHandlerContext context)
{
// code to handle order completion
MarkAsComplete();
}
public void Handle(CompleteOrder message)
{
logger.Info(string.Format("Saga with OrderId {0} received CompleteOrder with OrderId {1}", Data.OrderId, message.OrderId));
MarkAsComplete();
}
public void Handle(CompleteOrder message)
{
logger.InfoFormat("OrderSaga with OrderId {0} received CompleteOrder with OrderId {1}", Data.OrderId, message.OrderId);
Data.Count++;
//MarkAsComplete();
}
