public OrderService()
{
if (orderDataAccess == null)
{
orderDataAccess = new OrderDataAccess();
}
}
public async Task <string> SendOrderSuccessSMSNotification(CustomerDetails customer, string MessageName)
{
string status = string.Empty;
try
{
OrderDataAccess _orderAccess = new OrderDataAccess(_iconfiguration);
ConfigDataAccess _configAccess = new ConfigDataAccess(_iconfiguration);
DatabaseResponse smsTemplateResponse = await _configAccess.GetSMSNotificationTemplate(MessageName);
var notificationMessage = MessageHelper.GetSMSMessage(MessageName, ((SMSTemplates)smsTemplateResponse.Results).TemplateName, customer.Name, customer.DeliveryEmail, customer.ShippingContactNumber, customer.OrderNumber, customer.SlotDate.ToString("dd MMM yyyy"), new DateTime(customer.SlotFromTime.Ticks).ToString("hh:mm tt") + " to " + new DateTime(customer.SlotToTime.Ticks).ToString("hh:mm tt"));
DatabaseResponse notificationResponse = await _configAccess.GetConfiguration(ConfiType.Notification.ToString());
MiscHelper parser = new MiscHelper();
var notificationConfig = parser.GetNotificationConfig((List <Dictionary <string, string> >)notificationResponse.Results);
Publisher orderSuccessSMSNotificationPublisher = new Publisher(_iconfiguration, notificationConfig.SNSTopic);
status = await orderSuccessSMSNotificationPublisher.PublishAsync(notificationMessage);
LogInfo.Information("SMS send status : " + status + " " + JsonConvert.SerializeObject(notificationMessage));
return(status);
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical) + "SMS failure for OrderNumber:" + customer.OrderNumber);
throw ex;
}
}
public OrderServices()
{
orderDataAccess = new OrderDataAccess();
walletDataAccess = new WalletDataAccess();
walletServices = new WalletServices();
cryptocurrencyStoreServices = new CryptocurrencyStoreServices();
}
public OrderResponseModel GetDeliveredOrders(OrderRequestModel request)
{
OrderResponseModel response = new OrderResponseModel();
IOrderDataAccess _repository = new OrderDataAccess();
response.Orders = _repository.GetDeliveredOrders(request.OrderRequest);
return(response);
}
public OrderResponseModel GetOrdersOfFarmer(OrderRequestModel request)
{
OrderResponseModel response = new OrderResponseModel();
IOrderDataAccess _repository = new OrderDataAccess();
response.Orders = _repository.GetOrdersOfFamer(request.OrderRequest);
return(response);
}
public OrderResponseModel GetOrderDetailsById(OrderRequestModel request)
{
OrderResponseModel response = new OrderResponseModel();
IOrderDataAccess _repository = new OrderDataAccess();
response.OrderDetails = _repository.GetOrderDetailsById(request.OrderRequest);
return(response);
}
public async Task <Order> CreateAsync(OrderUpdateModel order)
{
await ClientGetService.ValidateAsync(order);
await BookGetService.ValidateAsync(order);
return(await OrderDataAccess.InsertAsync(order));
}
public async Task <Order> UpdateAsync(OrderUpdateModel order)
{
await BookGetService.ValidateAsync(order);
await CustomerGetService.ValidateAsync(order);
return(await OrderDataAccess.UpdateAsync(order));
}
public async Task SaveAsync()
{
var handler = new OrderDataAccess(this.Context, Mapper());
var entity = OrderTestData.OrderDTO;
var result = await handler.SaveAsync(entity);
var outcome = result.Id != 0;
Assert.IsTrue(outcome);
}
public async Task DeleteAsync()
{
var handler = new OrderDataAccess(this.Context, Mapper());
var entity = OrderTestData.OrderDTO;
await handler.SaveAsync(entity);
var response = await handler.DeleteAsync(entity.Id);
Assert.IsTrue(response);
}
public async Task <Order> CreateAsync(OrderUpdateModel order)
{
await BookGetService.ValidateAsync(order);
await CustomerGetService.ValidateAsync(order);
order.Date = DateTime.Now;
order.Arrived = false;
return(await OrderDataAccess.InsertAsync(order));
}
public async Task <int> FinalBuddyProcessing()
{
try
{
BSSAPIHelper bsshelper = new BSSAPIHelper();
OrderDataAccess _orderAccess = new OrderDataAccess(_iconfiguration);
DatabaseResponse configResponse = await _orderAccess.GetConfiguration(ConfiType.BSS.ToString());
GridBSSConfi config = bsshelper.GetGridConfig((List <Dictionary <string, string> >)configResponse.Results);
DatabaseResponse serviceCAF = await _orderAccess.GetBSSServiceCategoryAndFee(ServiceTypes.Free.ToString());
try
{
foreach (BuddyCheckList b in buddyActionList)
{
int process = await ProcessBuddy(b, config, (((List <ServiceFees>)serviceCAF.Results)).FirstOrDefault().ServiceCode);
}
List <BuddyCheckList> unProcessedBuddies = buddyActionList.Where(b => b.IsProcessed == false).ToList();
if (unProcessedBuddies != null && unProcessedBuddies.Count > 0)
{
foreach (BuddyCheckList upBuddy in unProcessedBuddies)
{
DatabaseResponse upBuddyCreateResponse = await _orderAccess.CreatePendingBuddyList(upBuddy);
}
return(0);
}
else
{
ProcessOrderQueueMessage(buddyActionList[0].OrderID);
return(1);
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(0);
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(0);
}
}
public AppResponseView CancellOrder(OrderDetailsModel request)
{
AppResponseView response = new AppResponseView();
IOrderDataAccess _repository = new OrderDataAccess();
response.Message = _repository.CancellOrder(request);
if (response.Message == "Order Cancelled successfully")
{
response.Status = 1;
}
return(response);
}
public async Task GetAllAsync()
{
var handler = new OrderDataAccess(this.Context, Mapper());
var entity = OrderTestData.OrderDTO;
await handler.SaveAsync(entity);
var response = await handler.GetAllAsync();
var outcome = response.Count;
Assert.IsTrue(outcome == 1);
}
public async Task <int> RemoveBuddyHandler(int orderID, int customerID)
{
try
{
OrderDataAccess _orderAccess = new OrderDataAccess(_iconfiguration);
DatabaseResponse checkBuddyResponse = await _orderAccess.CheckBuddyToRemove(orderID);
if (checkBuddyResponse.ResponseCode == (int)DbReturnValue.RecordExists && checkBuddyResponse.Results != null)
{
BuddyToRemove buddyToRemove = (BuddyToRemove)checkBuddyResponse.Results;
if (buddyToRemove.BuddyRemovalID > 0 && buddyToRemove.IsRemoved == 0 && buddyToRemove.IsPorted != 1)
{
BSSAPIHelper bsshelper = new BSSAPIHelper();
DatabaseResponse configResponse = await _orderAccess.GetConfiguration(ConfiType.BSS.ToString());
GridBSSConfi config = bsshelper.GetGridConfig((List <Dictionary <string, string> >)configResponse.Results);
DatabaseResponse serviceCAF = await _orderAccess.GetBSSServiceCategoryAndFee(ServiceTypes.Free.ToString());
DatabaseResponse requestIdToUpdateRes = await _orderAccess.GetBssApiRequestId(GridMicroservices.Order.ToString(), BSSApis.UpdateAssetStatus.ToString(), customerID, (int)BSSCalls.ExistingSession, buddyToRemove.MobileNumber);
BSSUpdateResponseObject bssUpdateResponse = new BSSUpdateResponseObject();
try
{
bssUpdateResponse = await bsshelper.UpdateAssetBlockNumber(config, (BSSAssetRequest)requestIdToUpdateRes.Results, buddyToRemove.MobileNumber, true);
DatabaseResponse updateBuddyRemoval = await _orderAccess.UpdateBuddyRemoval(buddyToRemove.BuddyRemovalID);
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical) + EnumExtensions.GetDescription(CommonErrors.BuddyRemovalFailed) + " for Order : " + orderID);
}
}
return(1);
}
else
{
return(0);
}
}
catch (Exception ex)
{
LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
return(0);
}
}
public int AddOrder(string foodName, string quantity, string totalAmmount, string date)
{
Order order = new Order()
{
Food_Name = foodName,
Quantity = Convert.ToInt32(quantity),
Total_Amount = Convert.ToDouble(totalAmmount),
Date = date
};
orderDataAccess = new OrderDataAccess();
return(this.orderDataAccess.AddOrder(order));
}
public void Handle(OrderEvent args)
{
//prob should be passing in id
var dto = new OrderDto
{
Id = args.Order.Id,
CustomerId = args.Order.Customer.Id,
EventId = args.Order.Evt.Id,
Quantity = args.Order.Quantity
};
OrderDataAccess.Create(dto);
}
public async Task SaveAsync()
{
var dataAccess = new OrderDataAccess(this.Context);
//Act
var sutCreate = new CreateOrderCommandHandler(dataAccess);
var resultCreate = await sutCreate.Handle(new CreateOrderCommand
{
Data = OrderTestData.OrderDataDTO
}, CancellationToken.None);
Assert.IsTrue(resultCreate.Succeeded);
}
public async Task <IActionResult> RemoveOrder(Order order)
{
try
{
await OrderDataAccess.RemoveOrderAsync(order);
return(Json(new RequestState(Status.Success, "Заказ успешно удален")));
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(Json(new RequestState(Status.Fail, "Не удалось выполнить требуемую операцию")));
}
}
public async Task UpdateAsync()
{
var handler = new OrderDataAccess(this.Context, Mapper());
var entity = OrderTestData.OrderDTO;
var originalOrder = entity;
await handler.SaveAsync(entity);
entity.Amount = new Faker().Finance.Amount();
var response = await handler.UpdateAsync(entity);
var outcome = response.Amount.Equals(originalOrder.Amount);
Assert.IsTrue(outcome);
}
public async Task <IActionResult> GetOrders()
{
try
{
var orders = await OrderDataAccess.GetOrdersAsync();
return(Json(new OrdersTable(orders)));
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(Json(new { data = "" }));
}
}
public ActionResult Payment(string shipName, string mobile, string address, string email)
{
var order = new Transaction();
order.CreatedDate = DateTime.Now;
order.User_Address = address;
order.User_Phone = mobile;
order.User_Name = shipName;
order.User_Email = email;
try
{
var id = new TransactionDataAccess().Insert(order);
var cart = (List <CartItem>)Session[CartSession];
var detailDataAccess = new OrderDataAccess();
double total = 0;
foreach (var item in cart)
{
var orderDetail = new Order();
orderDetail.ProductID = item.Product.ProductID;
orderDetail.TransactionID = id;
orderDetail.OrderID = id;
orderDetail.Quantity = item.Quantity;
orderDetail.Price = item.Product.Price;
orderDetail.Name = item.Product.Name;
detailDataAccess.Insert(orderDetail);
total += (item.Product.Price.GetValueOrDefault(0) * item.Quantity);
}
string content = System.IO.File.ReadAllText(Server.MapPath("~/assets/client/template/neworder.html"));
content = content.Replace("{{CustomerName}}", shipName);
content = content.Replace("{{Phone}}", mobile);
content = content.Replace("{{Email}}", email);
content = content.Replace("{{Address}}", address);
content = content.Replace("{{Total}}", total.ToString("N0"));
var toEmail = ConfigurationManager.AppSettings["ToEmailAddress"].ToString();
new MailHelper().SendMail(email, "Đơn hàng mới từ ShopHoa", content);
new MailHelper().SendMail(toEmail, "Đơn hàng mới từ ShopHoa", content);
}
catch (Exception ex)
{
//ghi log
return(Redirect("/loi-thanh-toan"));
}
return(Redirect("/hoan-thanh"));
}
public int AddNewOrder(string customerName, int customerNumber, string orderdCategory, string orderdFood, int price, string DeliveryType, string categoryName)
{
CategoryDataAccess categoryDataAccess = new CategoryDataAccess();
int categoryId = categoryDataAccess.GetCategoryId(categoryName);
Order order = new Order()
{
CustomerName = customerName,
CustomerNumber = customerNumber,
OrderdCategory = orderdCategory,
OrderdFood = orderdFood,
};
this.orderDataAccess = new OrderDataAccess();
return(this.orderDataAccess.AddOrder(order));
}
private void btnManageFunds_Click(object sender, EventArgs e)
{
OrderDataAccess ordersDA = new OrderDataAccess();
OrderDetailDataAccess detailsDA = new OrderDetailDataAccess();
mlvOrders.Items.Clear();
decimal loss = 0, profit = 0;
foreach (var order in ordersDA.GetList())
{
ListViewItem item = new ListViewItem(order.OrderID.ToString());
item.SubItems.Add(order.CustomerID.ToString());
item.SubItems.Add(order.OrderDate.ToLongTimeString());
item.SubItems.Add(order.OrderState.ToString());
if (detailsDA.GetList().Where(d => d.OrderID == order.OrderID).ToList().Count > 0)
{
foreach (var orderDetails in detailsDA.GetList().Where(d => d.OrderID == order.OrderID).ToList())
{
item.SubItems.Add(orderDetails.Loss + "$");
loss += orderDetails.Loss;
item.SubItems.Add(orderDetails.Profit + "$");
profit += orderDetails.Profit;
}
}
else
{
item.SubItems.Add("---- $");
item.SubItems.Add("---- $");
}
mlvOrders.Items.Add(item);
}
lblLoss.Text = loss.ToString() + "$";
lblProfit.Text = profit.ToString() + "$";
if ((profit - loss) > 0)
{
lblBalance.ForeColor = Color.SeaGreen;
lblBalance.Text = (profit - loss).ToString() + "$";
}
else
{
lblBalance.ForeColor = Color.Red;
lblBalance.Text = (loss - profit).ToString() + "$";
}
pnlManageFunds.Visible = true;
pnlManageFunds.BringToFront();
}
public async Task GetAllAsync()
{
var dataAccess = new OrderDataAccess(this.Context);
//Act
var sutCreate = new CreateOrderCommandHandler(dataAccess);
var resultCreate = await sutCreate.Handle(new CreateOrderCommand
{
Data = OrderTestData.OrderDataDTO
}, CancellationToken.None);
//Act
var sutGetAll = new GetOrdersQueryHandler(dataAccess);
var resultGetAll = await sutGetAll.Handle(new GetOrdersQuery(), CancellationToken.None);
Assert.IsTrue(resultGetAll?.Data.Count == 1);
}
public DataAccess(UserDataAccess userData, SessionDataAccess sessionData, UsersRolesDataAccess usersRolesData,
RoleDataAccess roleData, OrderDataAccess orderData, OrderRequestDataAccess orderRequestData,
WorkSessionDataAccess workSessionData, WorkImageDataAccess workImageData, ImageTypeDataAccess imageTypeData,
ExpensesDataAccess expenseData, ExpenseTypeDataAccess expenseTypeData)
{//begin constructor
UserData = userData;
SessionData = sessionData;
UsersRolesData = usersRolesData;
RoleData = roleData;
OrderRequestData = orderRequestData;
OrderData = orderData;
WorkSessionData = workSessionData;
WorkImageData = workImageData;
ImageTypeData = imageTypeData;
ExpenseData = expenseData;
ExpenseTypeData = expenseTypeData;
} //end constructor
public async Task GetAsync()
{
var dataAccess = new OrderDataAccess(this.Context);
//Act
var sutCreate = new CreateOrderCommandHandler(dataAccess);
var resultCreate = await sutCreate.Handle(new CreateOrderCommand
{
Data = OrderTestData.OrderDataDTO
}, CancellationToken.None);
//Act
var sutGet = new GetOrderQueryHandler(dataAccess);
var resultGet = await sutGet.Handle(new GetOrderQuery
{
Id = resultCreate.Data.Id
}, CancellationToken.None);
Assert.IsTrue(resultGet?.Data != null);
}
public async Task <IActionResult> AddOrder(NewOrderViewModel newOrder)
{
try
{
if (!ModelState.IsValid)
{
return(Json(new RequestState(Status.Fail, "Ошибка валидации", ModelState)));
}
var order = Mapper.Map <Order>(newOrder);
await OrderDataAccess.AddOrderAsync(order);
return(Json(new RequestState(Status.Success, "Заказ успешно добавлен")));
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(Json(new { status = false, message = "Не удалось выполнить требуемую операцию." }));
}
}
public async Task <IActionResult> UpdateOrder(UpdatingOrderViewModel updatingOrder)
{
try
{
if (!ModelState.IsValid)
{
return(Json(new RequestState(Status.Fail, "Ошибка валидации", ModelState)));
}
var order = Mapper.Map <Order>(updatingOrder);
await OrderDataAccess.UpdateOrderAsync(order);
return(Json(new RequestState(Status.Success, "Заказ успешно изменен")));
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
return(Json(new RequestState(Status.Fail, "Не удалось выполнить требуемую операцию")));
}
}
public async Task DeleteAsync()
{
var dataAccess = new OrderDataAccess(this.Context, Mapper());
//Act
var sutCreate = new CreateOrderCommandHandler(dataAccess);
var resultCreate = await sutCreate.Handle(new CreateOrderCommand
{
Data = OrderTestData.OrderDTO
}, CancellationToken.None);
//Act
var sutDelete = new DeleteOrderCommandHandler(dataAccess);
var outcomeDelete = await sutDelete.Handle(new DeleteOrderCommand
{
Id = resultCreate.Data.Id
}, CancellationToken.None);
//Assert
Assert.IsTrue(outcomeDelete.Succeeded);
}
