public void Add(PlacedOrder placedOrder)
{
using (var connection = new SqlConnection(this.connectionString))
{
connection.Execute("INSERT INTO PlacedOrder (OrderId, Name, Email, Address, ZipCode, City, TotalPrice, OrderDate) VALUES(@orderId, @name, @email, @address, @zipcode, @city, @totalPrice, @orderDate)", placedOrder);
}
}
public IActionResult CreateOrder(PlacedOrder placedOrder)
{
if (ModelState.IsValid)
{
var menuItems = _repo.MenuItem.GetMenuItemsByIds(placedOrder.OrderedItems.Select(x => x.MenuItemId).Distinct()).ToList();
var orderResult = InventoryCanMakeOrder(placedOrder, menuItems);
if (orderResult.Item1)
{
placedOrder.OrderedTimestamp = DateTime.Now;
placedOrder.UserId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
UpdateInventory(placedOrder, orderResult.Item3);
_repo.PlacedOrder.CreateOrder(placedOrder);
_repo.Save();
}
else
{
var menuItem = menuItems.Find(x => x.Recipe.Exists(x => x.IngredientId == orderResult.Item2));
var menuItemingredient = menuItem.Recipe.Find(x => x.IngredientId == orderResult.Item2);
var errorMessage = $"Sorry, we can't make {menuItem.Name} as we have don't have enough {menuItemingredient.Ingredient.Name}";
return(Json(new { ErrorMessage = errorMessage }));
}
return(RedirectToAction(nameof(Index)));
}
return(Json(placedOrder));
}
public bool createOrder(int orderId, PlacedOrder placedOrder)
{
if (orderId == 0)
{
return(false);
}
else
{
//Adding orderId and orderDate
placedOrder.OrderId = orderId;
placedOrder.OrderDate = GetTimestamp(DateTime.Now);
//Getting all order rows with the specified order no and sum their prices to get total price
List <PlacedOrderRows> allPlacedOrderRows = this.placedOrderRowsRepository.Get(orderId);
float sumAllPrices = 0;
foreach (var placedOrderRow in allPlacedOrderRows)
{
sumAllPrices += placedOrderRow.Price;
}
placedOrder.TotalPrice = sumAllPrices;
this.placedOrderRepository.Add(placedOrder);
}
return(true);
}
public PlacedOrderDTO OrderToPlacedOrderDTO(PlacedOrder givenOrder)
{
List <ItemGroupDTO> DTOList = new List <ItemGroupDTO>();
foreach (var item in givenOrder.OrderItems)
{
DTOList.Add(new ItemGroupDTO()
{
ItemID = item.ItemID,
ItemAmount = item.ItemAmount,
ShippingDate = item.ShippingDate,
PriceOf_OrderItemGroup = item.PriceOf_OrderItemGroup,
PricePerItem = item.PricePerItem
});
}
return(new PlacedOrderDTO()
{
OrderId = givenOrder.OrderId,
CostumerID = givenOrder.CostumerID,
OrderDate = givenOrder.OrderDate,
DateShipped = givenOrder.DateShipped,
OrderItems = DTOList,
TotalPriceOfOrder = givenOrder.TotalPriceOfOrder
});
}
public async Task <bool> SetCompleteOrder(PlacedOrder model)
{
var result = false;
var process = 0;
if (model.OrderTypeId == (int)EOrderType.DineIn)
{
process = (int)EOrderProcess.ServingOrder;
}
else if (model.OrderTypeId == (int)EOrderType.Delivery || model.OrderTypeId == (int)EOrderType.ToGo)
{
process = (int)EOrderProcess.AvailableOrder;
}
var processStatus = new PlacedOrderProcessStatus()
{
RestaurantId = _authenticationDto.RestaurantId,
BranchId = _authenticationDto.BranchId,
PlacedOrderId = model.Id,
OrderProcessId = process,
Status = 1,
CreatedStaffId = _authenticationDto.UserId,
CreatedDate = DateTime.Now
};
var lastProcessStatus = await _placedOrderProcessStatusBusiness.Add(processStatus);
if (lastProcessStatus != null)
{
result = true;
}
return(result);
}
public async Task <PlacedOrderProcessStatus> Add(PlacedOrderProcessStatus model)
{
var entity = _placedOrderProcessStatusRepository.Add(model);
if (entity != null)
{
var placedOrder = new PlacedOrder()
{
RestaurantId = entity.RestaurantId,
BranchId = entity.BranchId,
Id = entity.PlacedOrderId,
OrderProcessId = entity.OrderProcessId
};
// Update Order Process to Placed Order
var result = await UpdateOrderProcess(placedOrder);
if (result)
{
await _placedOrderProcessStatusRepository.SaveChangeAsync();
return(model);
}
}
return(null);
}
public async Task <PfxCertificate> FinalizeOrder(PlacedOrder placedOrder)
{
await Task.Delay(500);
OrderFinalizedCts.CancelAfter(250);
return(new PfxCertificate(FakeCert.RawData));
}
public async Task <bool> SetFinishOrder(PlacedOrder model, Checkout checkout)
{
var result = false;
var record = await _placedOrderRepository.Repo.FirstOrDefaultAsync(c => c.Id == model.Id);
if (record != null)
{
record.TaxId = model.TaxId;
record.Tax = model.Tax;
record.DiscountType = model.DiscountType;
record.Discount = model.Discount;
record.Description = model.Description;
record.IsFinish = 1;
record.UpdatedStaffId = model.UpdatedStaffId;
record.UpdatedDate = DateTime.Now;
if (record.DiscountType == (int)EDiscountType.Percent)
{
record.FinalPrice = record.Price + record.Tax - ((record.Price * record.Discount) / 100);
}
else if (record.DiscountType == (int)EDiscountType.Money)
{
record.FinalPrice = record.Price + record.Tax - record.Discount;
}
//modified checkout model
//if ReceivedAmount = 0, it mean no adding record to Checkout table
if (checkout.ReceivedAmount > 0)
{
checkout.RestaurantId = record.RestaurantId;
checkout.BranchId = record.BranchId;
checkout.PlacedOrderId = record.Id;
checkout.Amount = record.FinalPrice;
checkout.CreatedStaffId = record.UpdatedStaffId;
checkout.CreatedDate = DateTime.Now;
_checkoutRepository.Add(checkout);
}
//Add new process status
var processStatus = new PlacedOrderProcessStatus()
{
RestaurantId = record.RestaurantId,
BranchId = record.BranchId,
PlacedOrderId = record.Id,
OrderProcessId = (int)EOrderProcess.PaidOrder,
Status = 1,
CreatedStaffId = record.UpdatedStaffId,
CreatedDate = DateTime.Now
};
_placedOrderProcessStatusRepository.Add(processStatus);
await _unitOfWork.SaveChangesAsync();
result = true;
}
return(result);
}
public async Task <PlacedOrderDto> Post(PlacedOrder model)
{
PlacedOrderDto result = null;
//if current user is Restaurant Admin, don't let them create order
// because when update price will be wrong
if (_authenticationDto.TypeId == (int)EAccountType.Admin || _authenticationDto.TypeId == (int)EAccountType.Mod ||
_authenticationDto.TypeId == (int)EAccountType.RestaurantAdmin)
{
return(result);
}
if (ModelState.IsValid)
{
if (model.Tax == null)
{
model.Tax = 0;
}
if (model.DiscountType == null)
{
model.DiscountType = (int)EDiscountType.Money;
}
if (model.Discount == null)
{
model.Discount = 0;
}
model.RestaurantId = _authenticationDto.RestaurantId;
model.BranchId = _authenticationDto.BranchId;
model.OutputTypeId = (int)EOutputType.Order;
model.OrderTime = DateTime.Now;
model.CreatedDate = DateTime.Now;
model.CreatedStaffId = _authenticationDto.UserId;
model.Status = 1;
var modelInsert = await _placedOrderBusiness.Add(model);
result = modelInsert;
// add order process as a record
// Waiting Order Status
if (result != null)
{
var processStatus = new PlacedOrderProcessStatus()
{
RestaurantId = modelInsert.RestaurantId,
BranchId = modelInsert.BranchId,
PlacedOrderId = modelInsert.Id,
OrderProcessId = (int)EOrderProcess.WaitingOrder,
Status = 1,
CreatedStaffId = _authenticationDto.UserId,
CreatedDate = DateTime.Now
};
var lastProcessStatus = await _placedOrderProcessStatusBusiness.Add(processStatus);
}
}
return(result);
}
public Boolean PlaceOrder(PlacedOrderModel model)
{
var orders = new List <PlacedOrder>();
var modelK = _kartDA.GetCustomerKart(model.Customer_ID);
var orderNumber = _placeOrderDA.GetOrderNumber(); //Creating Order number
if (orderNumber == 0)
{
orderNumber = 999;
}
orderNumber += 1;
var modelA = _addressDA.GetAddress(model.Address_ID); //Creating Address
string address = "Address Line : " + modelA.AddressLine + " City : " + modelA.City + " State : " + modelA.State +
" Postal Code : " + modelA.PostalCode + " Address Type : " + modelA.AddressType;
foreach (var k in modelK)
{
if (k.Quantity == 0)
{
continue;
}
//common start
var order = new PlacedOrder();
order.Customer_ID = model.Customer_ID;
order.PaymentType = model.PaymentType;
order.Address = address;
order.DateTime = DateTime.Now;
order.Status = "Order Placed";
order.OrderNumber = orderNumber;
//common finish
var product = _productDA.GetProduct(k.Product_ID);
order.Quantity = k.Quantity;
var ActualPrice = product.ProductPrice - (product.ProductPrice * product.ProductDiscount) / 100;
order.Amount = k.Quantity * ActualPrice;
order.Product_ID = k.Product_ID;
product.ProductQuantityInKart -= k.Quantity; //releasing product IN kart value
product.ProductQuantity -= k.Quantity; //Normelizing Quantity
_kartDA.RemoveKartItem(k.ID, product); //remove from kart and updating product IN Kart value
orders.Add(order);
}
if (_placeOrderDA.PlaceOrder(orders))
{
return(true);
}
return(false);
}
public IActionResult Post(int orderId, [FromBody] PlacedOrder placedOrder)
{
var newOrder = this.placedOrderService.createOrder(orderId, placedOrder);
if (!newOrder)
{
return(BadRequest());
}
return(Ok());
}
public async Task <bool> Put(PlacedOrder model)
{
var result = false;
if (ModelState.IsValid)
{
model.UpdatedStaffId = _authenticationDto.UserId;
result = await _placedOrderBusiness.Update(model);
}
return(result);
}
public void UpdateInventory(PlacedOrder placedOrder, Dictionary <int, int> ingredientSums)
{
var inventoryItemsFromDb = _repo.InventoryItem.GetInventoryItemsByIngredientList(ingredientSums.Keys.ToList()).ToList();
foreach (var inventoryItem in inventoryItemsFromDb)
{
var amountNeeded = ingredientSums[inventoryItem.IngredientId];
inventoryItem.BulkPrice -= CalculateCost(amountNeeded, inventoryItem.Ingredient.BaseUnitOfWeight, inventoryItem.Ingredient.PricePerUnit);
inventoryItem.AmountInGrams -= amountNeeded;
inventoryItem.IsLow = InventoryItemIsLow(inventoryItem);
}
_repo.InventoryItem.UpdateRangeOfInventoryItems(inventoryItemsFromDb);
_repo.Save();
}
public async Task <bool> UpdateOrderProcess(PlacedOrder model)
{
var result = false;
var record = await _placedOrderRepository.Repo.FirstOrDefaultAsync(c => c.Id == model.Id);
if (record != null)
{
record.OrderProcessId = model.OrderProcessId;
await _placedOrderRepository.SaveChangeAsync();
result = true;
}
return(result);
}
public async Task OnNoValidCertificateAvailable_ShouldRenewCertificate()
{
// arrange
PersistenceService.GetPersistedSiteCertificateAsync().Returns(Task.FromResult(InvalidCert));
var dtos = new [] { new ChallengeDto {
Domains = new[] { "test.com" }, Token = "ping", Response = "pong"
} };
var placedOrder = new PlacedOrder(dtos, Substitute.For <IOrderContext>(), Array.Empty <IChallengeContext>());
LetsEncryptClient.PlaceOrder(SeqEq(new[] { "test.com" })).Returns(Task.FromResult(placedOrder));
PersistenceService.PersistChallengesAsync(dtos).Returns(Task.CompletedTask);
PersistenceService.DeleteChallengesAsync(dtos).Returns(Task.CompletedTask);
var newCertBytes = SelfSignedCertificate.Make(DateTime.Now, DateTime.Now.AddDays(90)).RawData;
LetsEncryptClient.FinalizeOrder(placedOrder).Returns(Task.FromResult(new PfxCertificate(newCertBytes)));
var newCertificate = new LetsEncryptX509Certificate(newCertBytes) as IPersistableCertificate;
PersistenceService.PersistSiteCertificateAsync(newCertificate).Returns(Task.CompletedTask);
// act
var output = await Sut.RenewCertificateIfNeeded(current : null);
// assert
output.Status.Should().Be(Renewed);
((LetsEncryptX509Certificate)output.Certificate).RawData.Should().BeEquivalentTo(newCertBytes);
CertificateValidator.Received(1).IsCertificateValid(null);
await PersistenceService.Received(1).GetPersistedSiteCertificateAsync();
CertificateValidator.Received(1).IsCertificateValid(InvalidCert);
await LetsEncryptClient.Received(1).PlaceOrder(SeqEq(new[] { "test.com" }));
await PersistenceService.Received(1).PersistChallengesAsync(dtos);
await PersistenceService.Received(1).DeleteChallengesAsync(dtos);
await PersistenceService.Received(1).PersistChallengesAsync(dtos);
await LetsEncryptClient.Received(1).FinalizeOrder(placedOrder);
await LetsEncryptClientFactory.Received(1).GetClient();
}
private async Task <bool> UpdateOrderProcess(PlacedOrder model)
{
var result = false;
var record = await _placedOrderRepository.Repo
.ToFilterByRole(f => f.RestaurantId,
f => f.BranchId, model.RestaurantId, model.BranchId)
.FirstOrDefaultAsync(c => c.Id == model.Id);
if (record != null)
{
record.OrderProcessId = model.OrderProcessId;
await _placedOrderRepository.SaveChangeAsync();
result = true;
}
return(result);
}
public (bool, int?, Dictionary <int, int>) InventoryCanMakeOrder(PlacedOrder placedOrder, IEnumerable <MenuItem> menuItems)
{
// (can we make it?, ingredientId we're out of, ingredientSums dictionary)
(bool, int?, Dictionary <int, int>)canMake = (true, null, new Dictionary <int, int>());
var groupedMenuItems = placedOrder.OrderedItems.GroupBy(x => x.MenuItemId).ToList();
//Key is ingredientId
//Value is total amount needed of that ingredient to make the order
var ingredientSums = menuItems.SelectMany(x => x.Recipe, (x, ingredient) => ingredient.IngredientId).Distinct().ToDictionary(x => x, x => 0);
var ingredientSumsFromInventory = new Dictionary <int, int>(ingredientSums);
canMake.Item3 = ingredientSums;
//build up amount of ingredients in inventory
ingredientSumsFromInventory.Keys.ToList().ForEach(key => ingredientSumsFromInventory[key] = _repo.InventoryItem.GetSumForIngredient(key));
// Big-O scary
foreach (var items in groupedMenuItems)
{
foreach (var item in items)
{
var menuItem = menuItems.Single(x => x.MenuItemId == item.MenuItemId);
foreach (var ingredient in menuItem.Recipe)
{
ingredientSums[ingredient.IngredientId] += ingredient.Quantity * item.Quantity;
}
;
}
}
foreach (var key in ingredientSums.Keys)
{
if (ingredientSums[key] > ingredientSumsFromInventory[key])
{
canMake.Item1 = false;
canMake.Item2 = key;
break;
}
}
return(canMake);
}
public async Task <bool> Update(PlacedOrder model)
{
var result = false;
var record = await _placedOrderRepository.Repo.FirstOrDefaultAsync(c => c.Id == model.Id);
if (record != null)
{
record.OrderTypeId = model.OrderTypeId;
record.CustomerId = model.CustomerId;
record.OrderChannelId = model.OrderChannelId;
record.TableId = model.TableId;
record.PeopleNum = model.PeopleNum;
record.CustomerName = model.CustomerName;
record.CustomerPhone = model.CustomerPhone;
record.OrderTime = model.OrderTime;
record.DeliveryTime = model.DeliveryTime;
record.DeliveryAddress = model.DeliveryAddress;
record.Tax = model.Tax;
record.DiscountType = model.DiscountType;
record.Discount = model.Discount;
record.Description = model.Description;
record.UpdatedStaffId = model.UpdatedStaffId;
record.UpdatedDate = DateTime.Now;
if (record.DiscountType == (int)EDiscountType.Percent)
{
record.FinalPrice = record.Price + record.Tax - ((record.Price * record.Discount) / 100);
}
else if (record.DiscountType == (int)EDiscountType.Money)
{
record.FinalPrice = record.Price + record.Tax - record.Discount;
}
await _placedOrderRepository.SaveChangeAsync();
result = true;
}
return(result);
}
public void RegisterNewOrder(List <ItemGroup> OrderGroup, Guid givenCostumerID)
{
Dictionary <Guid, int> dict = new Dictionary <Guid, int>();
foreach (var item in OrderGroup)
{
if (dict.ContainsKey(item.ItemID))
{
var dictResult = dict.Single(itemInDict => itemInDict.Key == item.ItemID);
dict.Remove(dictResult.Key);
dict.Add(dictResult.Key, dictResult.Value + item.ItemAmount);
}
else
{
dict.Add(item.ItemID, item.ItemAmount);
}
}
var DictionaryWithItemObject = GetDictionaryWithItemObject(dict);
CheckCostumerID(givenCostumerID);
PlacedOrder newOrder = new PlacedOrder(DictionaryWithItemObject, givenCostumerID);
PlacedOrderDatabase.OrderDB.Add(newOrder);
foreach (var item in DictionaryWithItemObject)
{
if (item.Key.Amount < item.Value)
{
item.Key.Amount = 0;
}
else
{
item.Key.Amount -= item.Value;
}
}
}
public async Task <PlacedOrderDto> Add(PlacedOrder model)
{
DateTime startDateTime = DateTime.Today; //Today at 00:00:00
DateTime endDateTime = DateTime.Today.AddDays(1).AddTicks(-1); //Today at 23:59:59
string dateStr = DateTime.Today.ToString("MMddyyyy");
string resStr = $"{(model.RestaurantId):D4}";
string braStr = $"{(model.BranchId):D4}";
model.Code = string.Empty;
var totalOrderToday = await _placedOrderRepository.Repo.Where(
c => c.CreatedDate >= startDateTime && c.CreatedDate <= endDateTime).CountAsync();
var entity = _placedOrderRepository.Add(model);
await _unitOfWork.SaveChangesAsync();
entity.Code = $"OD-{dateStr}{resStr}{braStr}{(totalOrderToday + 1):D5}";
await _unitOfWork.SaveChangesAsync();
model.Id = entity.Id;
model.Code = entity.Code;
return(_mapper.Map <PlacedOrderDto>(model));
}
public MarketOrderResponse([JsonProperty("payload")] PlacedOrder marketOrder)
{
Order = marketOrder;
}
public ActionResult Checkout(string FullName, string PhoneNo, string ShippingAddress, int PaymentMethod)
{
// validate current sub domain
domainIndentifier = new DomainIdentifier(Request.Url.Host, Request.ServerVariables["SERVER_NAME"]);
User User = domainIndentifier.GetUserRelatedDomain();
UserID = User != null ? User.Id : 0;
ViewBag.UserID = UserID;
Session["CurrentUserID"] = UserID;
// end of validation
//// check user is login or not
if (string.IsNullOrEmpty(Convert.ToString(Session["WebloggedUserID"])))
{
return(RedirectToAction("Login"));
}
long ShopUserID = Convert.ToInt64(Session["WebloggedUserID"]);
using (var Trac = db.Database.BeginTransaction())
{
try
{
var cart = (List <CartModel>)Session["cart"];
if (cart == null)
{
return(RedirectToAction("Cart"));
}
double? TotalPrice = 0;
List <Product> ProductDetail = new List <Product>();
foreach (var item in cart)
{
var CurrentProductDetail = db.Products.FirstOrDefault(x => x.Id == item.ProductID);
ProductDetail.Add(CurrentProductDetail);
TotalPrice += CurrentProductDetail.Price * item.Quantity;
}
PlacedOrder PlacedOrder = new PlacedOrder()
{
ReceivedPersonName = FullName,
ReceivedPhoneNumber = PhoneNo,
ShippingAddress = ShippingAddress,
TotalPrice = TotalPrice,
ShopUserID = ShopUserID,
OrderStatus = (int)OrderStatus.Pending,
OrderCreatedDateTime = DateTime.UtcNow,
PaymentMethod = (int)ShopPaymentMethod.CashOnDelivery
};
db.PlacedOrders.Add(PlacedOrder);
int IsPlacedOrderSaved = db.SaveChanges(); // Insert Record
List <Order> OrderList = new List <Order>();
foreach (var item in cart)
{
var ProductInfo = ProductDetail.FirstOrDefault(x => x.Id == item.ProductID);
if (ProductInfo != null)
{
OrderList.Add(new Order()
{
TotalPrice = ProductInfo.Price * item.Quantity,
Quantity = item.Quantity,
Discount = 0,
Price = ProductInfo.Price,
Tax = 0,
ProductID = ProductInfo.Id,
PlacedOrdersId = PlacedOrder.Id,
});
}
}
db.Orders.AddRange(OrderList);
int IsOrderSaved = db.SaveChanges(); // Insert Record
if (IsOrderSaved > 0 && IsPlacedOrderSaved > 0)
{
Trac.Commit();
TempData["CheckOutMsg"] = "<p class='text-success text-center'>Order has been Placed Succesfully!</p><b /><div class='text-center'><a href='/UserPanel/Orders/Detail'>Orders List</a></div>";
Session["cart"] = null;
return(View());
}
TempData["CheckOutMsg"] = "<p class='text-danger text-center'>There is an error. Please try agian if you face issue again. Please Contact to Support!</p>";
}
catch (Exception er)
{
Trac.Rollback();
TempData["CheckOutMsg"] = "<p class='text-danger text-center'>There is an error. Please try agian if you face issue again. Please Contact to Support!</p>";
}
}
return(View());
}
public LimitOrderResponse([JsonProperty("payload")] PlacedOrder order)
{
Order = order;
}
