public async Task <IActionResult> Create(OrderCreateInputModel input)
{
if (!this.ModelState.IsValid)
{
input = this.ordersService.LoadOrderCreateInputModel(input.Id);
return(this.View(input));
}
// var priceIn = this.financeService.GetAmount(input.OrderFromCurrencyId, input.OrderFromPriceNetIn);
// var priceOut = this.financeService.GetAmount(input.CurrencyOutId, input.PriceNetOut);
// var margin = priceIn - priceOut;
// var fromCurrencyId = this.currencies.AllAsNoTracking().FirstOrDefault(c => c.Name == CurrencyCodes.EUR.ToString()).Id;
//// if (priceIn < this.financeService.GetAmount(fromCurrencyId, GlobalConstants.SmallOrderMaxAmount) &&
//// margin < this.financeService.GetAmount(fromCurrencyId, GlobalConstants.SmallOrderMinMargin))
//// {
//// this.ModelState.AddModelError(string.Empty, "The order margin for order under 500€ cannot be less than 25€.");
//// input = this.ordersService.LoadOrderCreateInputModel(input.Id);
//// return this.View(input);
//// }
// var minMarginPer = priceIn * GlobalConstants.MinOrderMargin;
// if (margin < minMarginPer)
// {
// this.ModelState.AddModelError(string.Empty, "The order margin cannot be less than 5%.");
// input = this.ordersService.LoadOrderCreateInputModel(input.Id);
// return this.View(input);
// }
await this.ordersService.CreateAsync(input);
this.notyfService.Success(this.localizer["Order carrier found."]);
return(this.Redirect(@$ "/Orders/GenerateApplication/{input.Id}"));
}
public async Task CreateUproccessedOrder_ThrowsException_WhenShoppingCartIsEmptyOrNull()
{
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var orderRepository = new EfDeletableEntityRepository <Order>(context);
var userTestSeeder = new UserTestSeeder();
var shoppingCartProductSeeder = new ShoppingCartProductSeeder();
//seed user
await userTestSeeder.SeedUsersWithAddressesAsync(context);
var userWithoutProducts = context.Users.First(x => x.UserName == "UserWithoutAddresses");
var orderCreateInputModel = new OrderCreateInputModel()
{
};
var orderService = this.GetOrderService(orderRepository, context);
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await orderService.CreateUproccessedOrder(orderCreateInputModel, null);
});
await Assert.ThrowsAsync <ArgumentNullException>(async() =>
{
await orderService.CreateUproccessedOrder(orderCreateInputModel, userWithoutProducts.ShoppingCart.Id);
});
}
private async Task OrderSubmitted(OrderCreateInputModel model)
{
var bus = WebApiApplication.Bus;
model.CartId = Guid.Parse(model.UserId.Replace("Default", "").Replace("StorefrontAU", ""));
await bus.Publish <IOrderSubmitted>(model);
}
public async Task <OrderCreateViewModel> CreateAsync(OrderCreateInputModel orderFromView, string username, ModelStateDictionary modelState)
{
if (!modelState.IsValid)
{
var errorModel = await this.customersService.GetByIdAsync <OrderCreateViewModel>(orderFromView.CustomerId);
errorModel.IsExpress = orderFromView.IsExpress;
errorModel.HasFlavor = orderFromView.HasFlavor;
errorModel.ItemQuantitySetByUser = orderFromView.ItemQuantitySetByUser;
return(errorModel);
}
var hasAnyCustomerWithId = await this.customersService.IsCustomerExistAsync(orderFromView.CustomerId);
// If customer with Id NOT exists return existing view model
if (!hasAnyCustomerWithId)
{
throw new ArgumentNullException(nameof(orderFromView.CustomerId), string.Format(OrderConstants.NullReferenceCustomerId, orderFromView.CustomerId));
}
var orderToDb = orderFromView.To <Order>();
orderToDb.StatusId = await this.orderStatusService.GetIdByNameAsync(OrderConstants.StatusPickUpArrangeDayWaiting);
orderToDb.CreatorId = await this.employeesService.GetIdByUserNameAsync(username);
await this.orderRepository.AddAsync(orderToDb);
await this.orderRepository.SaveChangesAsync();
return(orderToDb.To <OrderCreateViewModel>());
}
public IActionResult Create(OrderCreateInputModel orderCreateInputModel)
{
string userId = this.User.FindFirst(ClaimTypes.NameIdentifier).Value;
OrderServiceModel orderServiceModel = AutoMapper.Mapper.Map <OrderServiceModel>(orderCreateInputModel);
this.orderService.Create(orderServiceModel, userId);
return(Redirect("/Order/Details"));
}
public async Task <IHttpActionResult> OrderCreated([FromBody] OrderCreateInputModel model)
{
if (!ModelState.IsValid)
{
return(InternalServerError(new Exception("Model is not valid")));
}
await OrderSubmitted(model);
return(Ok());
}
public async Task <IActionResult> Create(OrderCreateInputModel orederCreate)
{
var userName = this.User.Identity.Name;
var result = await this.ordersService.CreateAsync(orederCreate, userName, this.ModelState);
if (!this.ModelState.IsValid)
{
return(this.View(result));
}
return(this.Redirect($"/{GlobalConstants.AreaAdministrationName}/{GlobalConstants.ContollerCustomersName}"));
}
public async Task <IActionResult> Create(int id)
{
var user = await this.userManager.GetUserAsync(this.User);
var products = this.productsService.GetAll <ProductDropDownViewModel>(user.Id).ToList();
var viewModel = new OrderCreateInputModel
{
CustomerId = id,
Products = products,
};
return(View(viewModel));
}
public async Task <string> CreateAsync(OrderCreateInputModel input)
{
var order = this.orders.All().FirstOrDefault(o => o.Id == input.Id);
order.DueDaysTo = input.DueDaysTo;
input.OrderTos.Select(ot => ot.CarrierOrderCompanyId)
.Distinct()
.ToList()
.ForEach(id =>
{
order.CarrierOrders.Add(new CarrierOrder {
CompanyId = id, OrderTos = new List <OrderTo>()
});
});
foreach (var orderToInput in input.OrderTos)
{
var vehicle = this.vehicles.All().FirstOrDefault(v => v.Id == orderToInput.VehicleId);
if (!string.IsNullOrWhiteSpace(orderToInput.VehicleTrailerId))
{
vehicle.TrailerId = orderToInput.VehicleTrailerId;
await this.vehicles.SaveChangesAsync();
}
var orderTo = order.OrderTos.FirstOrDefault(o => o.Id == orderToInput.Id);
orderTo.PriceNetOut = orderToInput.PriceNetOut;
orderTo.CurrencyOutId = orderToInput.CurrencyOutId;
orderTo.ContactId = orderToInput.ContactId;
orderTo.VehicleId = orderToInput.VehicleId;
orderTo.TypeId = null;
orderTo.AdminId = order.AdminId;
orderTo.Drivers.Add(new DriverOrder {
OrderId = orderTo.Id, DriverId = orderToInput.DriverId,
});
var carrierOrder = order.CarrierOrders.FirstOrDefault(co => co.CompanyId == orderToInput.CarrierOrderCompanyId);
carrierOrder.OrderTos.Add(orderTo);
await this.carrierOrders.SaveChangesAsync();
carrierOrder.AdminId = order.AdminId;
}
await this.orders.SaveChangesAsync();
await this.UpdateOrderStatus(order.Id, OrderStatusNames.Ready.ToString());
return(order.Id);
}
public async Task <IActionResult> CreateOrder(OrderCreateInputModel model)
{
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction(
nameof(this.CreateOrder),
new { id = model.ProductId }));
}
string userId = this.userManager.GetUserId(this.User);
string orderId = await this.orderService.CreateAsync(model.ProductId, userId, model.Quantity);
await this.shoppingCartService.AddOrderAsync(userId, orderId);
return(this.RedirectToHome());
}
public async Task <Uri> CreateUriForPayment(OrderCreateInputModel inputModel)
{
var options = paypalOptions.CurrentValue;
PayPalEnvironment environment = CreateEnvironment();
var client = new PayPalHttpClient(environment);
var payment = new OrderRequest()
{
CheckoutPaymentIntent = "CAPTURE",
PurchaseUnits = new List <PurchaseUnitRequest>()
{
new PurchaseUnitRequest()
{
CustomId = inputModel.OrderId.ToString(),
Description = inputModel.Description,
AmountWithBreakdown = new AmountWithBreakdown()
{
CurrencyCode = inputModel.Price.Currency.ToString(),
Value = inputModel.Price.Amount.ToString(CultureInfo.InvariantCulture)
}
}
},
ApplicationContext = CreateApplicationContext()
};
//https://developer.paypal.com/docs/api/orders/v2/#orders_create
var request = new OrdersCreateRequest();
request.Prefer("return=representation");
request.RequestBody(payment);
try
{
var response = await client.Execute(request);
var statusCode = response.StatusCode;
var result = response.Result <Order>();
return(new Uri(result.Links.Single(l => l.Rel == "approve").Href));
}
catch (HttpException httpException)
{
var statusCode = httpException.StatusCode;
var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault();
logger.LogError($"Il tentativo di reindirizzare l'utente alla pagina di pagamento è fallito con status code {statusCode} e debugId {debugId}");
throw new PaymentException();
}
}
public async Task CreateUproccessedOrder(OrderCreateInputModel orderCreateInputModel, string shoppingCartId)
{
var shoppingCartProducts = await this.shoppingCartProductsService.GetAllProductsAsync <ShoppingCartProductInputModel>(shoppingCartId);
if (shoppingCartProducts == null || shoppingCartProducts.Count() == 0)
{
throw new ArgumentNullException("ShoppingCartId was null or empty");
}
decimal totalPrice = 0m;
decimal deliveryPrice = 0m;
var order = orderCreateInputModel.To <Order>();
await this.orderRepository.AddAsync(order);
foreach (var product in shoppingCartProducts)
{
order.OrderProducts.Add(new OrderProduct()
{
OrderId = order.Id,
ProductId = product.ProductId,
Quantity = product.Quantity
});
}
totalPrice = shoppingCartProducts.Sum(x => x.Quantity * x.ProductPrice);
if (orderCreateInputModel.PromoCodeId != null)
{
totalPrice = await this.promoCodeService.DeductPercentageFromPrice(totalPrice, orderCreateInputModel.PromoCodeId);
}
deliveryPrice = totalPrice >= 20m ? 0m : 3.5m;
order.OrderStatus = OrderStatus.UnProccessed;
order.DeliveryPrice = deliveryPrice;
order.TotalPrice = totalPrice + deliveryPrice;
order.OrderDate = DateTime.UtcNow;
await this.shoppingCartProductsService.DeleteAll(shoppingCartId);
await this.orderRepository.SaveChangesAsync();
}
public IActionResult Index()
{
ViewData["Title"] = "Paga l'ordine";
//Mostriamo alcuni dati fittizi nell'interfaccia per consentire la modifica dell'id dell'ordine e dell'importo
//In un'applicazione reale, questi valori arrivano dal database e per nessun motivo dovrebbero essere modificati dall'utente
var inputModel = new OrderCreateInputModel
{
OrderId = 123456,
Description = "Ordine merce",
Price = new Money
{
Amount = 11.00m,
Currency = Currency.EUR
}
};
return(View(inputModel));
}
public async Task <IActionResult> Create(OrderCreateInputModel inputModel)
{
if (!ModelState.IsValid)
{
return(this.View(inputModel));
}
var user = await this.userManager.GetUserAsync(HttpContext.User);
var result = await this.orderService.Create(user, inputModel.Phone, inputModel.ShippingAddress);
if (!result)
{
//to do
return(this.Redirect("/"));
}
return(this.RedirectToAction(nameof(SuccessfulOrder)));
}
public async Task CreateUnproccessedOrder_RemovesProductsFromShoppingCart_ProperlyCreatesAnOrderWithTheProducts()
{
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var orderRepository = new EfDeletableEntityRepository <Order>(context);
var userTestSeeder = new UserTestSeeder();
var shoppingCartProductSeeder = new ShoppingCartProductSeeder();
var productsTestSeeder = new ProductsTestSeeder();
//seed products
await productsTestSeeder.SeedProducts(context);
//seed users
await userTestSeeder.SeedUsersWithAddressesAsync(context);
var userWithProducts = context.Users.First(x => x.UserName == "UserWithoutAddresses");
//seed products in shoppingCart for user
await shoppingCartProductSeeder.SeedProductsToUser(context, userWithProducts);
var orderCreateInputModel = new OrderCreateInputModel()
{
UserId = userWithProducts.Id,
};
var orderService = this.GetOrderService(orderRepository, context);
await orderService.CreateUproccessedOrder(orderCreateInputModel, userWithProducts.ShoppingCart.Id);
var actualShoppingCartCount = userWithProducts.ShoppingCart.ShoppingCartProducts.Count();
var actualOrderCount = context.Orders.Count();
var order = context.Orders.FirstOrDefault();
var deliveryPrice = userWithProducts.ShoppingCart.ShoppingCartProducts.Sum(x => x.Quantity * x.Product.Price) >= 20m ? 0m : 3.5m;
var totalPrice = userWithProducts.ShoppingCart.ShoppingCartProducts.Sum(x => x.Quantity * x.Product.Price) + deliveryPrice;
Assert.Equal(OrderStatus.UnProccessed, order.OrderStatus);
Assert.Equal(deliveryPrice, order.DeliveryPrice);
Assert.Equal(totalPrice, order.TotalPrice);
Assert.Equal(0, actualShoppingCartCount);
Assert.Equal(1, actualOrderCount);
}
public IActionResult Create(OrderCreateInputModel orderCreateInputModel)
{
string username = this.User.FindFirst(ClaimTypes.Name).Value;
if (!this.ModelState.IsValid)
{
return(RedirectToAction("Create"));
}
var isCreated = this.orderService.CreateOrder(username, orderCreateInputModel.SupplierId, orderCreateInputModel.DeliveryType, orderCreateInputModel.AddressId);
if (!isCreated)
{
this.TempData["error"] = WebConstants.ErrorOrderMessage;
return(this.RedirectToAction("Create"));
}
return(this.RedirectToAction("Successfully"));
}
public async Task <IActionResult> Create(OrderCreateInputModel input)
{
var user = await this.userManager.GetUserAsync(this.User);
var products = this.productsService.GetAll <ProductDropDownViewModel>(user.Id).ToList();
var product = this.productsService.GetById <ProductViewModel>(input.ProductId);
if (product.Quantity < input.Quantity)
{
ModelState.AddModelError("", $"You cannot add {input.Quantity} because in your storage has only {product.Quantity}");
}
if (!ModelState.IsValid)
{
input.Products = products;
return(this.View(input));
}
await this.ordersService.CreateOrder(input.CustomerId, input.ProductId, input.Quantity);
return(this.RedirectToAction("Index", "Customers"));
}
public async Task <IActionResult> Index(OrderCreateInputModel inputModel, [FromServices] IPaymentService paymentService)
{
Uri url = await paymentService.CreateUriForPayment(inputModel);
return(Redirect(url.ToString()));
}
