//--------------------------------- 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);
}
}
//----------------------------- 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);
}
}
