public async Task AddOrder_WithId_ReturnsNull()
{
_order.Id = 5;
var result = await _repository.AddOrder(_order);
Assert.Null(result);
}
public static void AddOrder(Order orderToAdd)
{
try
{
Repo.AddOrder(orderToAdd);
}
catch (Exception e)
{
Logger.Log(e.Message);
throw new Exception("\tThere was an error adding your order:\n\t" + e.Message);
}
}
public ViewResult Checkout(Order order)
{
if (ModelState.IsValid && cart.Lines.Count() != 0)
{
order.Lines = cart.Lines.ToArray();
orderRepository.AddOrder(order);
cart.Clear();
return(View("Completed"));
}
else
{
return(View("Checkout"));
}
}
public List <Orders> AddOrder(OrderDTO orderDTO)
{
var order = Mapper.Map <Orders>(orderDTO);
var orderDetails = Mapper.Map <OrderDetails>(orderDTO);
return(_orderRepository.AddOrder(order, orderDetails));
}
public async Task <IActionResult> AddOrder([FromBody] SaveOrderResource saveOrder)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var order = mapper.Map <SaveOrderResource, Order>(saveOrder);
order.Date = DateTime.Now;
order.State = "Placed";
if (saveOrder.InvoiceId == 0)
{
order.InvoiceId = null;
}
if (saveOrder.TotalAmount == 0)
{
order.TotalAmount = 1;
}
orderRepository.AddOrder(order);
await unitOfWork.CompleteAsync();
order = await orderRepository.GetOrderAsync(order.Id);
order.TotalPrice = basketRepository.CalcBasketCost(order.Basket) * order.TotalAmount;
await unitOfWork.CompleteAsync();
var orderResource = mapper.Map <Order, OrderResource>(order);
return(Ok(orderResource));
}
public async Task <ValidationResult> Handle(CreateOrderCommand message, CancellationToken cancellationToken)
{
//Command Validation
if (!message.IsValid())
{
return(message.ValidationResult);
}
//Order Mapper
var order = OrderMap(message);
//ApplyVoucher
ApplyVoucher(message, order);
order.CalculateOrderAmount();
if (!await ProcessPayment(order, message.Payment))
{
return(ValidationResult);
}
order.AddEvent(new OrderStartedEvent(order.Id, order.CustomerId));
_orderRepository.AddOrder(order);
return(await Save(_orderRepository.UnitOfWork));
}
public string AddOrder(Order order)
{
var domainOrder = Mapper.Map <Domain.OrderManagement.Order>(order);
orderRepository.AddOrder(domainOrder);
return("Order created!");
}
public async Task <ActionResult> PostOrder(OrderRequestModel order)
{
order.CreatedDateTime = DateTime.UtcNow;
await _orderRepository.AddOrder(order);
return(Ok());
}
public async Task <Order> AddOrder(OrderDTO order)
{
try
{
Order newOrder = _mapper.Map <Order>(order);
Customer newCustomer = await _customerRepository.CreateCustomerIfNotExists(_mapper.Map <Customer>(newOrder.Customer));
newOrder.CustomerId = newCustomer.CustomerId;
newOrder.OrderId = Guid.NewGuid();
newOrder.Date = DateTime.Now.Date;
newOrder.OrderProducts = new List <OrderProduct>();
double total = 0.00;
foreach (var p in order.Products)
{
total += p.Price * p.Amount;
newOrder.OrderProducts.Add(new OrderProduct()
{
ProductId = p.Product.ProductId, OrderId = newOrder.OrderId, Quantity = p.Amount, IsPayed = false, UnitId = p.Unit
});
}
newOrder.InDebted = total;
await _orderRepository.AddOrder(newOrder);
return(newOrder);
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult AddOrder(AddOrderDTO dto)
{
Passenger passenger = _passengerRepo.GetPassengerBySeat(dto.SeatNumber);
if (passenger == null)
{
return(BadRequest());
}
Order order = new Order(passenger, dto.Time);
foreach (AddOrderlineDTO olDTO in dto.OrderlineDTOs)
{
Product product = _productRepo.GetProductById(olDTO.ProductId);
if (product == null)
{
return(BadRequest());
}
Orderline ol = new Orderline(olDTO.Number, product, order);
ol.CalculateTotalPrice();
order.AddOrderline(ol);
}
order.CalculateTotalPrice();
try
{
_orderRepo.AddOrder(order);
_orderRepo.SaveChanges();
}
catch (Exception)
{
return(StatusCode(500));
}
return(Ok(dto));
}
public async Task <IActionResult> MakeOrder(CreateOrderViewModel viewModel)
{
if (ModelState.IsValid)
{
OrderModel order = new OrderModel();
string items_string_list = "";
//When Created Id is +1 so in order of asigning it to the order item it needs to be decleared here
int orderId = _orderRepository.OrdersCount();
orderId++;
//Add right order items to the database
for (int i = 0; i < viewModel.OrderItems.Count; i++)
{
viewModel.OrderItems[i].OrderId = orderId;
order.FullItemsAmmount += viewModel.OrderItems[i].Ammount;
_orderItemRepository.Add(viewModel.OrderItems[i]);
items_string_list += $"Product: {viewModel.OrderItems[i].ProductName} | Quantity: {viewModel.OrderItems[i].Ammount} \n";
}
order.OrderDate = DateTime.Now;
order.SupplierName = viewModel.SupplierName;
_orderRepository.AddOrder(order);
SuppliersModel supplier = _supplierRepository.GetSupplier(viewModel.SupplierId);
//Send email with order
//await PostMail(supplier, order, items_string_list);
return(RedirectToAction("DisplayOrders"));
}
return(View());
}
// sets the add edit or delete response into motion for adding an order
public AddEditOrDeleteOrderResponse AddOrder(string orderDate, Order order)
{
AddEditOrDeleteOrderResponse response = new AddEditOrDeleteOrderResponse();
DateValidation(orderDate);
Order validatedOrder = OrderValidation(order);
if ((Date.OrderDate.ToString() == Date.DATE_TIME_ORIGIN) || (validatedOrder == null))
{
response.Order = null;
}
else
{
response.Order = _orderRepository.AddOrder(Date.OrderDate, validatedOrder);
}
if (response.Order == null)
{
response.Success = false;
response.Message = "The order could not be added.";
}
else
{
response.Success = true;
}
return(response);
}
public void AddOrder([FromBody] Order order)
{
if (ModelState.IsValid)
{
_orderRepository.AddOrder(order);
}
}
public bool ProcessOrder(Order order)
{
if (_inventoryRepository.CheckInventory(order.Item.ProductID, order.Quantity))
{
if (_paymentService.ChargePayment(order.CardInfo.creditCardNumber, order.CardInfo.amount))
{
_orderRepository.AddOrder(order);
StringBuilder body = new StringBuilder();
body.AppendLine("A new order has been submitted");
EmailSettings emailSettings = new EmailSettings();
MailMessage mailMessage = new MailMessage(
emailSettings.MailFromAddress,
emailSettings.MailToAddress,
"New order submitted!",
body.ToString());
_emailService.SendEmail(mailMessage);
return(true);
}
else
{
throw new Exception("Payment Declined");
}
}
else
{
throw new Exception("The ordered Qunatity is not available");
}
}
public bool AddOrder(OrderModel model)
{
var order = Mapper.Map <OrderEntity>(model);
order.SubscriberId = UserContext.Current.SubscriberId;
if (_orderRepository.AddOrder(order))
{
if (model.HasCharges)
{
if (!AddChargeValues(order, model.Charges))
{
var charges = JsonConvert.SerializeObject(model.Charges);
}
}
if (model.HasProperties)
{
if (!AddPropertyValues(order, model.Properties))
{
var properties = JsonConvert.SerializeObject(model.Properties);
}
}
return(true);
}
return(false);
}
public void AddIntoBasket(Int32?productId)
{
if ((productId != null) && (User.Identity.IsAuthenticated))
{
_repository.AddOrder(User.Identity.Name, (Int32)productId);
}
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
_logger.LogInformation("Post");
if (ModelState.IsValid)
{
var newEntity = _mapper.Map <OrderViewModel, Order>(model);
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
newEntity.User = currentUser;
_orderRepository.AddOrder(newEntity);
if (_orderRepository.SaveChanges())
{
return(Created($"/api/orders/{newEntity.Id}", _mapper.Map <Order, OrderViewModel>(newEntity)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError("Error", ex);
}
return(BadRequest("Failed"));
}
protected void saveOrder(object sender, EventArgs e)
{
IOrderRepository orderRepository = RepositoryFactory.Get <IOrderRepository>();
Order orderCreate;
if (validateFields())
{
orderCreate = new Order();
orderCreate.userID = getUserID();
orderCreate.job_name = this.txtJobName.Text;
orderCreate.width = Int32.Parse(this.txtFinalSizeX.Text);
orderCreate.height = Int32.Parse(this.txtFinalSizeY.Text);
orderCreate.quantity = Int32.Parse(this.txtQty.Text);
orderCreate.stock_finish = this.lstFinish.SelectedValue;
orderCreate.stock_weight = this.lstWeight.SelectedValue;
orderCreate.two_sided = this.chkTwoSide.Checked;
orderCreate.folded = this.chkfolded.Checked;
orderCreate.ship = this.chkShip.Checked;
orderCreate.price = calculatePrice(orderCreate);
orderRepository.AddOrder(orderCreate);
orderRepository.SubmitChanges();
this.lblNotify.Text = "Order Created Sucessfull! with ID :" + orderCreate.orderID;
this.lblNotify.ForeColor = System.Drawing.Color.Blue;
this.lblNotify.Visible = true;
func_clearFields(false);
}
}
public IActionResult CreateOrder([FromBody] OrderToCreateDto orderToCreate)
{
try
{
if (orderToCreate == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(new UnprocessableEntityObjectResult(ModelState));
}
var orderEntity = Mapper.Map <Order>(orderToCreate);
_repo.AddOrder(orderEntity);
if (!_repo.Save())
{
throw new Exception("Error creating order.");
}
var eventMessage = new OrderCreatedIntegrationEvent(orderEntity);
_eventBus.Publish(eventMessage);
var orderToReturn = Mapper.Map <OrderDto>(orderEntity);
return(CreatedAtRoute("GetOrder", new { id = orderToReturn.Id }, orderToReturn));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> Post([FromBody] OrderViewModel model)
{
try
{
if (ModelState.IsValid)
{
var newOrder = _mapper.Map <OrderViewModel, Order>(model);
if (newOrder.OrderDate == DateTime.MinValue)
{
newOrder.OrderDate = DateTime.Now;
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
newOrder.User = currentUser;
_repository.AddOrder(newOrder);
if (_repository.SaveAll())
{
return(Created($"api/orders/{newOrder.OrderId}", _mapper.Map <Order, OrderViewModel>(newOrder)));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception e)
{
_logger.LogError($"Failed to save new order: {e} ");
}
return(BadRequest("Failed to Save new order"));
}
public Order PlaceOrder(Dictionary <int, int> shoppingCart, DeliveryDataDTO deliveryData)
{
var order = new Order
{
ZipCode = deliveryData.ZipCode,
City = deliveryData.City,
Address = deliveryData.Address,
PhoneNumber = deliveryData.PhoneNumber,
InfoToDelivery = deliveryData.InfoToDelivery,
UserId = deliveryData.UserId
};
_orderRepository.AddOrder(order);
foreach (var shoppingCartElement in shoppingCart)
{
var orderProduct = new OrderProduct
{
ProductId = shoppingCartElement.Key,
Amount = shoppingCartElement.Value,
Order = order
};
_orderProductRepository.AddOrderProduct(orderProduct);
}
_orderRepository.Commit();
_orderProductRepository.Commit();
return(order);
}
public IActionResult Index(CheckoutViewFormModel form)
{
if (ModelState.IsValid)
{
var newOrder = new Order()
{
Name = form.Name,
AddressLine1 = form.AddressLine1,
AddressLine2 = form.AddressLine2,
City = form.City,
Postcode = form.Postcode,
Country = form.Country
};
foreach (var item in _shoppingCart._shoppingCart)
{
newOrder.orderDetails.Add(
new OrderDetails {
Amount = item.Quantity,
ProductDetailId = item.Product.ProductDetailId
}
);
}
_orderRepository.AddOrder(newOrder);
_shoppingCart.ClearShoppingCart();
return(RedirectToAction("OrderComplete"));
}
form._shoppingCart = _shoppingCart._shoppingCart;
return(View(form));
}
public AddOrderResponse AddOrder(Orders order)
{
DisplayOrderResponse orderResponse = new DisplayOrderResponse();
orderResponse.orders = _orderRepository.DisplayOrder();
AddOrderResponse addResponse = new AddOrderResponse();
addResponse.orders = order;
if (orderResponse.orders != null && orderResponse.orders.Where(c => c.OrderNumber == order.OrderNumber).Count() > 0)
{
addResponse.Success = false;
addResponse.Message = $"{order.OrderNumber} is already existed.";
return(addResponse);
}
if (!_orderRepository.AddOrder(order))
{
addResponse.Success = false;
addResponse.Message = $"Cannot add {order.OrderNumber}.";
}
else
{
addResponse.Success = true;
addResponse.Message = $"Successfully added order {order.OrderNumber}.";
}
return(addResponse);
}
public bool AddOrder(OrderContract orderContract)
{
var order = _mapper.GetOrderFromOrderContract(orderContract);
var state = _orderrepository.AddOrder(order);
return(state);
}
public async Task <IActionResult> AddOrder([FromBody] OrderAddDto order)
{
Guid userID = new(User.FindFirst(ClaimTypes.NameIdentifier)?.Value);
var user = userRepository.GetUserAsync(userID);
if (user == null)
{
return(NotFound(nameof(userID)));
}
var itemCount = order.OrderItems.Count();
if (itemCount == 0)
{
return(UnprocessableEntity("Order item is empty!"));
}
var now = DateTime.Now;
string orderID = $"{(now.Year-2020).ToString().PadLeft(2,'0')}{(now.DayOfYear*24*60+now.Hour*60+now.Minute).ToString().PadLeft(6,'0')}{(user.Id % 10000).ToString().PadLeft(4,'0')}{random.Next(10000).ToString().PadLeft(4,'0')}";
var orderItems = new List <OrderItem>(itemCount);
decimal originalPrice = 0m;
foreach (var addItem in order.OrderItems)
{
var product = await productRepository.GetProductAsync(addItem.ProductID);
var orderItem = new OrderItem()
{
OrderID = orderID,
ProductID = addItem.ProductID,
Price = product.Price,
Amount = addItem.Amount,
};
orderItems.Add(orderItem);
originalPrice += product.Price * addItem.Amount;
}
Order orderEntity = new()
{
UserID = userID,
OrderID = orderID,
OrderItems = orderItems,
Status = OrderStatus.待付款,
OrderTime = now,
ShippingAddrId = order.ShippingAddrId,
CouponAmount = CalcCoupon(),
OriginalPrice = originalPrice,
ShippingFare = CalcShippingFare(),
};
orderRepository.AddOrder(userID, orderEntity);
await orderRepository.SaveAsync();
var dtoToReturn = mapper.Map <OrderDetailDto>(orderEntity);
return(CreatedAtRoute(nameof(GetOrder), new { userID, orderID }, dtoToReturn));
}
public IActionResult Post([FromBody] Order newOrder)
{
var user = (User)this.HttpContext.Items[cnst_userKey];
_repo.AddOrder(user, newOrder);
return(Ok());
}
public async Task <Order> AddOrder(OrderForCreationDto orderForCreationDto)
{
var order = await _orderFormattingService.BuildOrder(orderForCreationDto);
await _orderRepository.AddOrder(order);
return(order);
}
/// <summary>
/// Eine Bestellung wird für das Produkt angelegt.
/// </summary>
/// <param name="product"></param>
public Order OrderCoffee(Product product)
{
Order o = new Order();
o.Product = product;
_orderRepository.AddOrder(o);
return(o);
}
private void _FakeAnOrder(int orderNumber, Customer c, IOrderRepository _repository)
{
var order = new Order(c);
_repository.SetFieldWhenReconstitutingFromPersistence(order, "_orderNumber", orderNumber);
_repository.AddOrder(order);
}
/// <summary>
/// Añade un pedido
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public async Task <bool> AddOrder(OrderDataAPI value)
{
// Si no tenemos asociada la referencia no es correcto
if (String.IsNullOrEmpty(value?.Reference) || (!IsAdmin() && !IsVehicle()))
{
return(false);
}
// Si existe un pedido con esa referencia devolvemos un fallo
if (await _orderRepository.Find(value.Reference, value.ReferenceUniqueAccess) != null)
{
return(false);
}
Guid?vehicleId = null;
Guid?userId = null;
if (!String.IsNullOrEmpty(value.UserName))
{
var usr = await _userRepository.GetUser(value.UserName);
userId = usr?.Id;
}
// Chequeamos que el vehiculo exista en caso de estar indicado
if (!String.IsNullOrEmpty(value.ReferenceVehicle))
{
var vehicle = await _vehicleRepository.Find(value.ReferenceVehicle);
if (vehicle == null)
{
return(false);
}
// Solo asociamos el vehiculo si es administrador o el usuario es el que lo tiene asignado
if (IsAdmin() || vehicle.UserId == GetUserId())
{
vehicleId = vehicle?.Id;
}
else
{
throw new ExtendedResultException(new StatusCodeResult(StatusCodes.Status401Unauthorized));
}
}
// Si no es administrador asociamos el vehiculo
if (!IsAdmin())
{
// Asignamos el primer vehiculo del usuario asociado
var vehicles = await _vehicleRepository.GetVehicles(GetUserId());
vehicleId = vehicles?.FirstOrDefault()?.Id;
}
if (!Enum.IsDefined(typeof(OrderStatus), value.Status))
{
value.Status = vehicleId.HasValue ? OrderStatus.Assigned : OrderStatus.Added;
}
// Creamos el pedido
return(await _orderRepository.AddOrder(value, userId, vehicleId));
}
private static void AddOrderToRepository(IOrder o, IOrderRepository r)
{
r.AddOrder(o.ID,
o.Contract,
o.OrderType,
o.MarketSide,
o.Price,
o.Quantity,
o.ClOrdID,
o.Account);
}
