public async Task <OrderConfirmation> Neworder(CreateOrderDto model)
{
// Call asynchronous network methods in a try/catch block to handle exceptions
try
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, OrderResource)
{
Content = new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json")
};
HttpResponseMessage response = await _httpClient.SendAsync(request);
if (response.IsSuccessStatusCode)
{
var confirmation =
JsonConvert.DeserializeObject <OrderConfirmation>(await response.Content.ReadAsStringAsync());
return(confirmation);
}
}
catch (HttpRequestException e)
{
_logger.Error("Error: {@error}", e.Message);
}
return(new OrderConfirmation()
{
OrderSucess = false
});
}
public IActionResult Checkout(OrderViewModel orderViewModel)
{
if (ModelState.IsValid)
{
var createOrderViewModel = new CreateOrderDto
{
OrderViewModel = orderViewModel,
OrderItems = _cartService.TransformCart().Items
.Select(o => new OrderItem
{
Id = o.Key.Id,
Price = o.Key.Price,
Quantity = o.Value
})
.Select(o => o.ToDto()).ToList()
};
var orderResult = _orderService.CreateOrder(
createOrderViewModel, User.Identity.Name);
_cartService.RemoveAll();
return(RedirectToAction("OrderConfirmed",
new { id = orderResult.Id }));
}
var detailsViewModel = new OrderDetailsViewModel
{
OrderViewModel = orderViewModel,
CartViewModel = _cartService.TransformCart()
};
return(View("Details", detailsViewModel));
}
public IActionResult Post([FromForm] CreateOrderDto dto)
{
try
{
_createOrder.Execute(dto);
return(Ok());
}
catch (EntityNotFoundException e)
{
return(NotFound(e.Message));
}
catch (EntityMissmatchException e)
{
if (e.Message.Contains("count"))
{
return(BadRequest(e.Message));
}
return(UnprocessableEntity(e.Message));
}
catch (ProductNotAvailableException e)
{
return(BadRequest(e.Message));
}
catch (InvalidInputException e)
{
return(BadRequest(e.Message));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public async Task AddBadRequestStatus()
{
//Arrange
var userManager = GetMockUserManager();
User user = new User {
Id = 1, UserName = "******"
};
CreateOrderDto createOrder = new CreateOrderDto {
Reference = "430000"
};
ReferenceToAddOrderDto reference = new ReferenceToAddOrderDto {
Reference = "430000"
};
Plan plan = new Plan {
Id = 5, Reference = "430000"
};
userManager.Setup(x => x.FindByIdAsync("1")).Returns(Task.FromResult(user));
warehouseMock.Setup(x => x.GetOrders("bc1")).Returns(Task.FromResult(GetPlans()));
mapperMock.Setup(x => x.Map <Plan>(createOrder)).Returns(plan);
warehouseMock.Setup(x => x.Add(plan));
warehouseMock.Setup(x => x.SaveAll()).Returns(Task.FromResult(false));
PlanController controller = new PlanController(warehouseMock.Object, mapperMock.Object, userManager.Object);
//Act
var action = await controller.AddOrder("bc1", 1, reference, 2) as BadRequestObjectResult;
//Arrange
Assert.Equal(400, action.StatusCode);
}
public async Task <IActionResult> Basket(CreateOrderDto createOrderDto)
{
if (!ModelState.IsValid)
{
int userId = Convert.ToInt32(User.FindFirst("UserId").Value);
createOrderDto.UserAddresses = await _userAddressService.GetListAsync(userId);
return(View(createOrderDto));
}
IDataResult <CartDTO> cart = await _cartService.GetCart();
if (cart.IsSuccess)
{
Order result = await _orderService.CreateOrder(cart.Data, createOrderDto);
if (result.Id != 0)
{
TempData["ToastModel"] = result.Id.ToString();
}
else
{
TempData["ToastModel"] = "Bir Hata ile karşılaşıldı !";
}
}
else
{
TempData["ToastModel"] = "Sepette Ürün Bulunamadı !";
}
return(RedirectToAction(nameof(PaymentResult), "Cart"));
}
public async Task <IActionResult> CreateOrder([FromBody] CreateOrderDto model)
{
var order = _mapper.Map <Order>(model);
foreach (var container in order.ProductsContainers)
{
container.OrderId = order.Id;
container.Order = order;
container.Product = await _productRepository.GetByIdAsync(container.ProductId);
}
order.TotalPrice = _orderService.CalculateTotalPrice(order);
var insertResult = await _orderRepository.InsertAsync(order);
await _emailSender.SendEmailAsync(
(HttpContext.RequestServices.GetService(typeof(IConfiguration)) as IConfiguration)?["EmailCredential:Email"],
order.Email,
"Info",
MailsContainer.GetMailForCreateOrder(order));
if (insertResult >= 1)
{
return(Ok("Success"));
}
return(BadRequest("Can't insert order"));
}
public async Task CreateOrder([FromRoute] string userName, [FromBody] OrderProductDto dto)
{
HttpClient client = _httpClientFactory.CreateClient();
client.BaseAddress = new Uri("https://localhost:5001/");
var requestDto = new CreateOrderDto
{
Count = dto.Count,
Item = dto.Item
};
HttpResponseMessage response = await client.PostAsJsonAsync("api/OrderManager", requestDto);
if (!response.IsSuccessStatusCode)
{
throw new Exception("Order failed");
}
int orderId = Convert.ToInt32(await response.Content.ReadAsStringAsync());
List <int> orderList;
if (!_userManager.TryGetValue(userName, out orderList))
{
orderList = new List <int>();
_userManager[userName] = orderList;
}
orderList.Add(orderId);
}
public IActionResult Create(CreateOrderDto createOrderDto)
{
if (createOrderDto.BookIds.Count == 0)
{
return(BadRequest(ModelState));
}
if (ModelState.IsValid)
{
var response = _ordersService.Create(createOrderDto.ToDomainModel());
if (!response)
{
return(BadRequest(ModelState));
}
else
{
return(Ok());
}
}
else
{
return(BadRequest(ModelState));
}
}
public ActionResult CreateOrder(CreateOrderDto input)
{
var order = new PurchaseOrder
{
DateTime = input.Date,
VendorId = input.VendorId,
Discount = input.Discount,
Items = new List <LineItem>()
};
input.Items.ForEach(x =>
{
order.Items.Add(new LineItem
{
ProductId = x.ProductId,
Quantity = x.Quantity,
UnitPrice = x.UnitPrice
});
});
var db = new ApplicationDbContext();
db.PurchaseOrders.Add(order);
db.SaveChanges();
return(Json(new { sucess = true }));
}
public async Task <IActionResult> PostOrder([FromBody] CreateOrderDto orderdto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var orderObj = _mapper.Map <Order>(orderdto);
try
{
await _orders.Add(orderObj);
}
catch (DbUpdateException)
{
if (!await OrderExists(orderObj.Id))
{
return(NotFound());
}
else
{
return(BadRequest());
}
}
return(CreatedAtAction("GetOrder", new { id = orderObj.Id }, orderObj));
}
public void Execute(CreateOrderDto request)
{
_validator.ValidateAndThrow(request);
var order = new Order
{
Address = request.Address,
UserId = request.UserId,
OrderDate = request.OrderDate
};
foreach (var item in request.Items)
{
var book = _context.Books.Find(item.BookId);
book.Quantity -= item.Quantity;
order.OrderLines.Add(new OrderLine
{
BookId = item.BookId,
Quantity = item.Quantity,
Name = book.Title,
Price = book.Price,
OrderId = order.Id
});
}
_context.Orders.Add(order);
_context.SaveChanges();
}
public OrderDto CreateOrder(CreateOrderDto createOrderDto,
string userName)
{
var response = Post($"{ServiceAddress}/{userName}", createOrderDto);
return(response.Content.ReadAsAsync <OrderDto>().Result);
}
public async Task <Order> CreateAsync(CreateOrderDto model)
{
var order = new Order
{
CustomerId = model.CustomerId,
EmployeeId = model.EmployeeId
};
var details = model.OrderDetailDto.
Select(d => new OrderDetail()
{
OrderId = d.OrderId,
ProductId = d.ProductId,
UnitPrice = d.UnitPrice,
Quantity = d.Quantity,
Discount = d.Discount
});
order.OrderDetails = details.ToList <OrderDetail>();
_uow.Add(order);
await _uow.CommitAsync();
return(order);
}
public CreateOrderResponse Create(CreateOrderDto createOrderDto)
{
//get by ids
var books = booksService.GetByIds(createOrderDto.BookIds);
//create new order object
var newOrder = new Order
{
Name = createOrderDto.Name,
Address = createOrderDto.Address,
Email = createOrderDto.Email,
Phone = createOrderDto.Phone,
BookOrders = createOrderDto.BookIds.Select(x => new BookOrders {
BookId = x
}).ToList(),
FullPrice = books.Sum(x => x.Price),
OrderCode = Helper.RandomString(6)
};
//save
ordersRepository.Create(newOrder);
var response = new CreateOrderResponse();
response.OrderCode = newOrder.OrderCode;
return(response);
}
public async Task CreateShouldSaveNew()
{
var dto = new CreateOrderDto()
{
CustomerId = _random.Next().ToString().PadLeft(5),
EmployeeId = _random.Next(),
OrderDetailDto = new List <OrderDetailDto>()
{
new OrderDetailDto()
{
ProductId = _random.Next(),
Quantity = (short)_random.Next(),
UnitPrice = _random.Next(),
Discount = _random.Next(1)
}
}
};
var result = await _query.CreateAsync(dto);
result.CustomerId.Should().Be(dto.CustomerId);
result.EmployeeId.Should().Be(dto.EmployeeId);
result.OrderDetails.Count().Should().Be(1);
_uow.Verify(x => x.Add(result));
_uow.Verify(x => x.CommitAsync());
}
public virtual async Task <Order> GenerateAsync(CreateOrderDto input, Dictionary <Guid, ProductDto> productDict, Dictionary <string, object> orderExtraProperties)
{
var orderLines = new List <OrderLine>();
foreach (var orderLine in input.OrderLines)
{
orderLines.Add(await GenerateNewOrderLineAsync(orderLine, productDict));
}
var productTotalPrice = orderLines.Select(x => x.TotalPrice).Sum();
var order = new Order(
id: _guidGenerator.Create(),
tenantId: _currentTenant.Id,
storeId: input.StoreId,
customerUserId: _currentUser.GetId(),
currency: await GetStoreCurrencyAsync(input.StoreId),
productTotalPrice: productTotalPrice,
totalDiscount: orderLines.Select(x => x.TotalDiscount).Sum(),
totalPrice: productTotalPrice,
refundedAmount: 0,
customerRemark: input.CustomerRemark);
foreach (var orderExtraProperty in orderExtraProperties)
{
order.SetProperty(orderExtraProperty.Key, orderExtraProperty.Value);
}
order.SetOrderLines(orderLines);
order.SetOrderNumber(await _orderNumberGenerator.CreateAsync(order));
return(order);
}
public IActionResult Create(CreateOrderDto createOrderDto)
{
try
{
if (ModelState.IsValid)
{
var response = _ordersService.Create(createOrderDto.ToModel());
if (response.IsSuccessfull)
{
return(Ok(response.Message));
}
else
{
ModelState.AddModelError("", response.Message);
//return BadRequest(ModelState);
}
}
return(BadRequest(ModelState));
}
catch (Exception)
{
return(StatusCode(500));
}
}
public void Execute(CreateOrderDto request)
{
_validator.ValidateAndThrow(request);
int IdUser = actor.Id;
var order = new Order
{
UserId = IdUser,
Address = request.Address,
Date = request.OrderDate
};
foreach (var item in request.Items)
{
var product = _context.Products.Find(item.ProductId);
product.Quantity -= item.Quantity;
order.OrderInfo.Add(new OrderInfo
{
Name = product.Name,
Quantity = item.Quantity,
Price = product.Price,
ProductId = item.ProductId,
});;
}
_context.Orders.Add(order);
_context.SaveChanges();
}
public IActionResult CreateOrder(CreateOrderDto dto)
{
if (!TryValidateModel(dto))
{
return(this.View(dto));
}
;
var quantity = int.Parse(dto.Quantity);
var productId = dto.productId;
var selectedTableId = dto.DisplayTable;
var product = this._productsService.GetProductById(productId);
var totalPrice = quantity * product.Price;
var orderSuccessful = this._ordersService.AddOrder(selectedTableId, DateTime.Now, quantity, product.Id, totalPrice).Result;
if (!orderSuccessful)
{
return(View("OrderNotCompleted"));
}
return(Redirect("/"));
}
public void Execute(CreateOrderDto dto)
{
_validator.ValidateAndThrow(dto);
var order = new Order
{
UserId = dto.Id,
Address = dto.Address,
OrderDate = dto.OrderDate
};
foreach (var item in dto.Items)
{
var product = _context.Products.Find(item.ProductId);
product.Quantity -= item.Quantity;
order.OrderLines.Add(new OrderLine
{
ProductId = item.ProductId,
Quantity = item.Quantity,
Name = product.Name,
Price = product.Price
});
}
_context.Orders.Add(order);
_context.SaveChanges();
}
public IActionResult CheckOut(OrderViewModel model)
{
if (ModelState.IsValid)
{
var orderModel = new CreateOrderDto()
{
OrderViewModel = model,
OrderItems = new List <OrderItemDto>()
};
foreach (var orderItem in _cartService.TransformCart().Items)
{
// Todo: студентам самостоятельно перенести в OrderItemMapper
orderModel.OrderItems.Add(new OrderItemDto()
{
Id = orderItem.Key.Id,
Price = orderItem.Key.Price,
Quantity = orderItem.Value
});
}
var orderResult = _ordersService.CreateOrder(orderModel, User.Identity.Name);
_cartService.RemoveAll();
return(RedirectToAction("OrderConfirmed", new { orderResult.Id }));
}
var detailsModel = new OrderDetailsViewModel()
{
CartViewModel = _cartService.TransformCart(),
OrderViewModel = model
};
return(View("Details", detailsModel));
}
public async Task <AttrResultModel> UpdateOrder([FromBody] CreateOrderDto orderDto)
{
//这里如果不指定主键的话，默认会按照实体的第一个带有ID的字段为主键,建议手动指定
var result = await client.UpdateHasValueFieldAsync <CreateOrderDto, R01_Order>(orderDto, "更新出错", "R01_OrderId");
result = await client.UpdateAsync <CreateOrderDto, R01_Order>(orderDto, "更新出错", "R01_OrderId");
result = await client.ExecUpdateSql <R01_Order>(null, "Update R01_Order set R01_OrderNo = 'test' where R01_OrderId = 1", "更新出错");
OrderUpdate orderUpdate = new OrderUpdate()
{
C02_CustomerId = 1,
P01_ProductId = 1,
P02_ProductFlowId = 1,
R01_OrderNo = "11"
};
//生成的sql
/*
* Update tableName
* set DbfieldName2 = @C02_CustomerId,
* DbfieldName3 = @P01_ProductId,
* DbfieldName4 = @P02_ProductFlowId
* Where DbfieldName1 = @R01_OrderNo
*/
result = await client.UpdateAsync(orderUpdate);
return(result);
}
public virtual async Task <Money?> GetAssetCategoryBookingUnitPriceAsync(CreateOrderDto input,
CreateOrderLineDto inputOrderLine, Currency effectiveCurrency)
{
var productAssetCategory = (await _productAssetCategoryAppService.GetListAsync(
new GetProductAssetCategoryListDto
{
MaxResultCount = 1,
StoreId = input.StoreId,
ProductId = inputOrderLine.ProductId,
ProductSkuId = inputOrderLine.ProductSkuId,
AssetCategoryId = inputOrderLine.GetBookingAssetCategoryId(),
PeriodSchemeId = inputOrderLine.GetBookingPeriodSchemeId()
}
)).Items.First();
var productAssetCategoryPeriod =
productAssetCategory.Periods.FirstOrDefault(x => x.PeriodId == inputOrderLine.GetBookingPeriodId());
if (productAssetCategoryPeriod is not null)
{
await CheckCurrencyAsync(productAssetCategoryPeriod.Currency, effectiveCurrency);
return(new Money(productAssetCategoryPeriod.Price, effectiveCurrency));
}
if (productAssetCategory.Price.HasValue)
{
await CheckCurrencyAsync(productAssetCategory.Currency, effectiveCurrency);
return(new Money(productAssetCategory.Price.Value, effectiveCurrency));
}
return(null);
}
public void FromCreateDto_ReturnModelToGetDtoCanConvert()
{
var customerGuid = Guid.NewGuid();
var orderGoodGuid = Guid.NewGuid();
var createOrderDto = new CreateOrderDto
{
CustomerId = customerGuid,
CreationDate = new DateTime(2020, 12, 20),
PaymentStatus = PaymentStatus.Paid,
DeliveryStatus = DeliveryStatus.DeliveryWaiting,
Goods = new List <OrderGoodDto>
{
new OrderGoodDto {
Id = orderGoodGuid, Quantity = 12
}
}
};
var orderConverter = new OrderConverter();
var order = orderConverter.FromCreateDto(createOrderDto);
var getOrderDto = orderConverter.ToGetDto(order);
Assert.AreEqual(getOrderDto.Customer.Id, createOrderDto.CustomerId);
Assert.AreEqual(getOrderDto.CreationDate, createOrderDto.CreationDate);
Assert.AreEqual(getOrderDto.PaymentStatus, createOrderDto.PaymentStatus);
Assert.AreEqual(getOrderDto.DeliveryStatus, createOrderDto.DeliveryStatus);
}
public async Task <IActionResult> CreateOrder(CreateOrderDto dto)
{
User user = (User)await this._manager.FindByNameAsync(HttpContext.User.Identity.Name);
Order order = new Order()
{
PostAddress = dto.Address,
date = DateTime.Now,
Status = Status.Opened,
UserId = user.Id,
User = user
};
await this._context.SaveChangesAsync();
Bucket bucket = (from i in this._context.Buckets
where i.UserId.Equals(user.Id)
select i).ToList <Bucket>().First();
var books = (from i in this._context.Books
where i.BucketId == bucket.Id
select i).ToList <Book>();
books.ForEach(b =>
{
b.OrderId = order.Id;
b.Order = order;
b.BucketId = null;
b.Bucket = null;
});
await this._context.SaveChangesAsync();
return(RedirectToAction("GetBucketInfo", "User"));
}
public CreateOrderDto CreateOrder([FromBody] CreateOrderDto orderDto)
{
using (GameShopDBContext gameShopDBContext = new GameShopDBContext())
{
var GameId = gameShopDBContext.Games
.Where(x => x.GameName == orderDto.GameName)
.Select(x => x.Id).FirstOrDefault();
var PlayerId = gameShopDBContext.Players
.Where(x => x.PlayerName == orderDto.PlayerName)
.Select(x => x.Id).FirstOrDefault();
Order SaveOrder = new Order();
SaveOrder.gameid = GameId;
SaveOrder.playerid = PlayerId;
SaveOrder.DiscountPrice = orderDto.DiscountPrice;
gameShopDBContext.Orders.Add(SaveOrder);
gameShopDBContext.SaveChanges();
orderDto.Id = SaveOrder.Id;
return(orderDto);
}
}
public async Task CheckoutOrder_ReturnNotFound_WhenCustomerIsNotFound()
{
// Arrange
var mapper = Substitute.For <IMapper>();
var bookService = Substitute.For <IBookService>();
var customerService = Substitute.For <ICustomerService>();
var orderService = Substitute.For <IOrderService>();
var stockService = Substitute.For <IStockService>();
var orderController = new OrderController(mapper, bookService, customerService, orderService, stockService);
// Act
var order = new CreateOrderDto()
{
OrderNote = "Test Order",
CustomerId = -1,
OrderProducts = new List <CreateOrderProductDto>()
{
new CreateOrderProductDto()
{
BookId = 1, Quantity = 1
},
new CreateOrderProductDto()
{
BookId = 2, Quantity = 1
}
}
};
var insertedOrder = await orderController.Checkout(order);
// Assert
Assert.IsType <NotFoundObjectResult>(insertedOrder);
}
public IActionResult Post([FromBody] CreateOrderDto dto,
[FromServices] ICreateOrderCommand command)
{
dto.Id = actor.Id;
executor.ExecuteCommand(command, dto);
return(NoContent());
}
protected virtual async Task <OrderLine> GenerateOrderLineAsync(CreateOrderDto input,
CreateOrderLineDto inputOrderLine, Dictionary <Guid, ProductDto> productDict)
{
var product = productDict[inputOrderLine.ProductId];
var productSku = product.GetSkuById(inputOrderLine.ProductSkuId);
if (!inputOrderLine.Quantity.IsBetween(productSku.OrderMinQuantity, productSku.OrderMaxQuantity))
{
throw new OrderLineInvalidQuantityException(product.Id, productSku.Id, inputOrderLine.Quantity);
}
var totalPrice = productSku.Price * inputOrderLine.Quantity;
return(new OrderLine(
id: _guidGenerator.Create(),
productId: product.Id,
productSkuId: productSku.Id,
productModificationTime: product.LastModificationTime ?? product.CreationTime,
productDetailModificationTime: productSku.LastModificationTime ?? productSku.CreationTime,
productGroupName: product.ProductGroupName,
productGroupDisplayName: product.ProductGroupDisplayName,
productUniqueName: product.UniqueName,
productDisplayName: product.DisplayName,
skuName: productSku.Name,
skuDescription: await _productSkuDescriptionProvider.GenerateAsync(product, productSku),
mediaResources: product.MediaResources,
currency: productSku.Currency,
unitPrice: productSku.Price,
totalPrice: totalPrice,
totalDiscount: 0,
actualTotalPrice: totalPrice,
quantity: inputOrderLine.Quantity
));
}
public async void Add_Order_ShouldReturnOk()
{
//Arrange
var fakeOrderService = A.Fake <IOrderService>();
CreateOrderResponseDto expectedDto = new CreateOrderResponseDto();
expectedDto.RawOrderResponse = "steak, potato(x2), cake";
A.CallTo(() => fakeOrderService.Add(A <string> .Ignored))
.Returns(Task.FromResult(expectedDto.RawOrderResponse));
var orderController = new OrderController(fakeOrderService);
CreateOrderDto createOrderDto = new CreateOrderDto();
createOrderDto.RawOrder = "night, 1, 2, 2, 4";
//Act
var result = await orderController.Add(createOrderDto);
var okObjectResult = result.Result as OkObjectResult;
var createOrderResponseDto = okObjectResult.Value as CreateOrderResponseDto;
//Assert
Assert.IsType <OkObjectResult>(okObjectResult);
Assert.Equal(createOrderResponseDto.RawOrderResponse, expectedDto.RawOrderResponse);
}
