public async Task <IActionResult> Checkout([FromBody] OrderCreateRequest request)
{
try
{
var user = await _userManager.GetUserAsync(HttpContext.User);
if (user == null)
{
return(BadRequest(ErrorCodes.INVALID_REQUEST));
}
if (request.Lines == null || !request.Lines.Any())
{
return(BadRequest(ErrorCodes.ORDER_NO_PRODUCT_IN_CART));
}
if (ModelState.IsValid)
{
var result = await _orderService.SaveOrderAsync(request, user);
return(Ok(result));
}
else
{
return(BadRequest(ErrorCodes.ORDER_MISSING_ADDRESS_OR_PHONENUMBER));
}
}
catch (Exception ex)
{
return(BadRequest(ex.InnerException));
}
}
public async Task <ActionResult <OrderViewModel> > PostAsync(OrderCreateRequest request)
{
foreach (var item in request.Items)
{
var products = _orleansClient.GetGrain <IProducts>(Guid.Empty);
var exists = await products.Exists(item.ProductId);
if (!exists)
{
return(NotFound());
}
if (item.Quantity < 0)
{
ModelState.AddModelError(nameof(item.Quantity), "Invalid");
return(BadRequest(ModelState));
}
}
var Order = MapFromRequest(request);
var Orders = _orleansClient.GetGrain <IOrders>(Guid.Empty);
var result = await Orders.Add(Order);
var response = MapToViewModel(result);
return(response);
}
public async Task <IActionResult> AddOrder(string phone, string fullAddress, string customerEmail)
{
List <CartItemViewModel> cart = HttpContext.Session.Get <List <CartItemViewModel> >("UserCart");
var orderVM = new OrderCreateRequest {
Phone = phone,
FullAddress = fullAddress,
CustomerEmail = customerEmail,
Cost = 0,
OrderStatus = "XN",
orderDetail = new List <OrderDetailViewModel>()
};
foreach (var el in cart)
{
orderVM.Cost += el.Price * el.Qty;
orderVM.orderDetail.Add(new OrderDetailViewModel {
Qty = el.Qty, ProductId = el.ProductId
});
}
var result = await _orderApiClient.addOrder(orderVM);
if (result)
{
Task.WaitAll(Task.Delay(2000));
return(RedirectToAction("Index", "Home"));
}
else
{
Task.WaitAll(Task.Delay(2000));
return(RedirectToAction("Index", "Cart"));
}
}
public async Task <IActionResult> PostOrder(OrderCreateRequest orderRequest)
{
var postOrder = new OrderHeader
{
Phone = orderRequest.Phone,
CustomerEmail = orderRequest.CustomerEmail,
Cost = orderRequest.Cost,
FullAddress = orderRequest.FullAddress,
OrderStatus = orderRequest.OrderStatus
};
foreach (var el in orderRequest.orderDetail)
{
postOrder.OrderDetails.Add(new OrderDetail
{
Qty = el.Qty,
ProductId = el.ProductId,
Order = postOrder
});
}
var isPostSuccessOrder = await _orderService.CreateOrder(postOrder);
if (isPostSuccessOrder)
{
return(NoContent());
}
else
{
return(NotFound());
}
}
public async void CanCreateOrder()
{
const int productId = 1;
const int applicantId = 2;
//so complex because PG rounds milliseconds to 6 digits
var now = DateTimeOffset.Now;
var dateAdd = new DateTimeOffset(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, 123, now.Offset);
var request = new OrderCreateRequest
{
ProductId = productId,
ApplicantId = applicantId,
DateAdd = dateAdd
};
var order = await _client.CreateOrderAsync(request);
Assert.Equal(applicantId, order.ApplicantId);
Assert.Equal(productId, order.ProductId);
Assert.Equal(dateAdd, order.DateAdd);
var orderId = order.Id;
order = await _client.GetOrderAsync(orderId);
Assert.Equal(orderId, order.Id);
Assert.Equal(applicantId, order.ApplicantId);
Assert.Equal(productId, order.ProductId);
Assert.Equal(dateAdd, order.DateAdd);
}
public OrderCreateResponse Create(OrderCreateRequest request)
{
var response = new OrderCreateResponse();
_facade.Create(request.Order);
return(response);
}
public async Task OrdersController_Checkout_Order_No_Product_In_Cart()
{
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, _fixture.Users[0].UserName),
new Claim(ClaimTypes.NameIdentifier, _fixture.Users[0].Id)
}, "mock"));
var userManager = _fixture.ServiceProvider.GetRequiredService <UserManager <User> >();
var controller = new OrdersController(_fixture.OrderService, userManager)
{
ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext()
{
User = user
}
}
};
var request = new OrderCreateRequest
{
Address = "ABC Street, XYZ City",
PhoneNumber = "123 456 789"
};
var result = await controller.Checkout(request);
var badResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(badResult.Value.ToString(), ErrorCodes.ORDER_NO_PRODUCT_IN_CART);
}
public async Task <ApiResult <bool> > Create(OrderCreateRequest request)
{
Order order = new Order()
{
OrderDate = DateTime.UtcNow,
UserId = request.UserId,
OrderDetails = request.ListCart.Select(x => new OrderDetail()
{
ProductId = x.ProductId,
Quantity = x.Quantity,
Price = x.Price
}).ToList(),
ShipAddress = request.ShipAddress,
ShipEmail = request.ShipEmail,
ShipName = request.ShipName,
ShipPhoneNumber = request.ShipPhoneNumber,
Status = OrderStatus.InProgress
};
_context.Orders.Add(order);
if (await _context.SaveChangesAsync() != 0)
{
return(new ApiSuccessResult <bool>());
}
return(new ApiErrorResult <bool>());
}
private void AddToCart(ref Order order, OrderCreateRequest orderCreateRequest)
{
var productExistOrder = order.orderDetails.Where(x => x.productId == orderCreateRequest.productId).FirstOrDefault();
if (productExistOrder != null)
{
if (productExistOrder.quantity + orderCreateRequest.quantity <= 0)
{
context.OrderDetails.Remove(productExistOrder);
//order.orderDetails.Remove(productExistOrder);
}
else
{
productExistOrder.quantity += orderCreateRequest.quantity;
order.updatedDate = DateTime.Now;
}
}
else
{
productExistOrder = new OrderDetail {
productId = orderCreateRequest.productId, quantity = orderCreateRequest.quantity, orderId = order.orderId
};
order.updatedDate = order.createdDate = DateTime.Now;
order.orderDetails.Add(productExistOrder);
}
}
public async Task <int> Create(OrderCreateRequest request)
{
var tempUser = await _context.Users.FindAsync(request.UserId);
var tempCartList = await _context.Carts.Where(x => x.UserId == request.UserId).ToListAsync();
var newOrder = new Order()
{
OrderDate = DateTime.Now,
ShipAddress = tempUser.Address + " " + tempUser.City + " " + tempUser.State,
ShipName = tempUser.FirstName + " " + tempUser.LastName,
ShipEmail = tempUser.Email,
ShipPhoneNumber = tempUser.PhoneNumber,
UserId = tempUser.Id,
Status = Data.Enums.OrderStatus.InProgress,
OrderDetails = new List <OrderDetail>(),
};
for (var i = 0; i < tempCartList.Count; i++)
{
var newOrderDetail = new OrderDetail()
{
ItemId = tempCartList[i].ItemId,
Quantity = tempCartList[i].Quantity,
Price = tempCartList[i].Price,
};
await _context.OrderDetails.AddAsync(newOrderDetail);
_context.Carts.Remove(tempCartList[i]);
newOrder.OrderDetails.Add(newOrderDetail);
}
await _context.Orders.AddAsync(newOrder);
return(await _context.SaveChangesAsync());
}
public async Task <Order> PutOrderAsync(OrderCreateRequest order, string userId)
{
Order orderToBeAdded;
var productInDB = await context.Products.FindAsync(order.productId);
if (!context.Orders.Any(o => o.user.Id == userId))
{
return(null);
}
else
{
orderToBeAdded = await context.Orders.Where(o => o.user.Id == userId).Include(o => o.orderDetails).FirstOrDefaultAsync();
AddToCart(ref orderToBeAdded, order);
}
try
{
await context.SaveChangesAsync();
return(orderToBeAdded);
}
catch (Exception e)
{
return(null);
}
}
public static Order MapFromRequest(OrderCreateRequest request)
{
return(new Order
{
Items = request.Items.Select(x => MapFromRequest(x)).ToList(),
Name = request.Name,
});
}
/// <summary>Call the POS for Order method</summary>
/// <param name="request">The request</param>
public OrderCreatePOSResponse OrderTransaction(OrderCreateRequest request)
{
OrderCreatePOSResponse response = new OrderCreatePOSResponse();
// TODO: call (calls) to POS
return(response);
}
public async Task <OrderCreateResponse> SaveOrder(OrderCreateRequest order)
{
var request = new HttpRequestMessage(HttpMethod.Post, BackEndUrls.SaveOrder())
{
Content = new StringContent(JsonConvert.SerializeObject(order), Encoding.UTF8, "application/json")
};
return(await _apiServive.SendAsync <OrderCreateResponse>(request));
}
public async Task <IActionResult> PostAsync([FromBody] OrderCreateRequest request, CancellationToken cancellationToken)
{
var phoneNumber = User.FindFirst(ClaimTypes.NameIdentifier).Value;
request.PhoneNumber = phoneNumber;
var responseModel = await this.mediator.Send(request, cancellationToken);
return(new CustomActionResult(responseModel));
}
private void VerifySignature(ActionExecutingContext filterContext, string path, table_商户账号 dbAccount)
{
string apiPassword = dbAccount.商户密码API;
string secret = dbAccount.公共密匙;
int? timeunix = filterContext.ActionParameters[tsKey] as int?;
Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
if (unixTimestamp - timeunix.Value > 180)
{
filterContext.Result = GetStandardError(BaseErrors.ERROR_NUMBER.LX1006, dbAccount.商户ID, unixTimestamp + "-" + timeunix.Value + "=" + (unixTimestamp - timeunix.Value));
return;
}
string signature = filterContext.ActionParameters[signKey] as string;
string source;
if (path.Contains("AccountInquiry"))
{
source = dbAccount.商户ID + apiPassword + timeunix + secret;
}
else if (path.Contains("OrderInquire"))
{
OrderInquireRequest orderInquireRequest = filterContext.ActionParameters["request"] as OrderInquireRequest;
source = dbAccount.商户ID + apiPassword + timeunix + orderInquireRequest.OrderNumberMerchant + secret;
}
else if (path.Contains("OrderCreate"))
{
OrderCreateRequest orderCreateRequest = filterContext.ActionParameters["request"] as OrderCreateRequest;
source = dbAccount.商户ID + apiPassword + timeunix
+ orderCreateRequest.OrderNumberMerchant
+ orderCreateRequest.AimsCardNumber
+ orderCreateRequest.AimsCardName
+ orderCreateRequest.AimsCardBank
+ orderCreateRequest.AimsMoney
+ secret;
}
else
{
filterContext.Result = GetStandardError(BaseErrors.ERROR_NUMBER.LX1018, dbAccount.商户ID);
return;
}
using (MD5 md5Hash = MD5.Create())
{
if (!VerifyMd5Hash(md5Hash, source, signature))
{
if (dbAccount.签名错误累计 > MAX_ERROR_COUNT)
{
filterContext.Result = GetStandardError(BaseErrors.ERROR_NUMBER.LX1002, dbAccount.商户ID);
}
else
{
dbAccount.签名错误累计++;
sqlSugarClient.Updateable(dbAccount).UpdateColumns(it => new { it.签名错误累计 }).ExecuteCommand();;
filterContext.Result = GetStandardError(BaseErrors.ERROR_NUMBER.LX1004, dbAccount.商户ID);
}
}
}
}
public async Task <IActionResult> Create(OrderCreateRequest request)
{
var result = await _orderService.Create(request);
if (result > 0)
{
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> CreateAsync([FromBody] OrderCreateRequest request)
{
if (request == null)
{
return(Fail(WebResource.CreateRequestIsEmpty));
}
var id = await OrderService.CreateAsync(request);
return(Success(id));
}
public async Task <IActionResult> Checkout()
{
var request = new OrderCreateRequest
{
ListCart = await GetListCart(CultureInfo.CurrentCulture.Name),
//UserId = (Guid)await _userApiClient.GetUserId()
};
return(View(request));
}
public async Task <IActionResult> CreateOrder(OrderCreateRequest request)
{
var result = await this.orderService.CreateOrder(request);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
return(this.Ok(result));
}
public void should_create_order()
{
var items = new List <StackItem>
{
new StackItem
{
ProductId = 6,
Amount = 2
},
new StackItem
{
ProductId = 7,
Amount = 5
}
};
var request = new OrderCreateRequest
{
OrderItems = new List <OrderItemCreateRequest>
{
new OrderItemCreateRequest
{
ProductId = 6,
Amount = 1
},
new OrderItemCreateRequest
{
ProductId = 7,
Amount = 2
}
}
};
items.ForEach(i => ResolveSession().Save(i));
var orderService = new OrderService(ResolveSession(), new OrderRepository(ResolveSession()), new StackItemRepository(ResolveSession()));
orderService.CreateOrder(request);
var orders = ResolveSession().Query <Order>().ToList();
Assert.Equal(1, orders.Count);
var orderItems = ResolveSession().Query <OrderItem>().ToList();
Assert.Equal(1, orderItems.Single(i => i.ProductId == 6).Amount);
Assert.Equal(2, orderItems.Single(i => i.ProductId == 7).Amount);
var stackItems = ResolveSession().Query <StackItem>().ToList();
Assert.Equal(1, stackItems.Single(i => i.ProductId == 6).Amount);
Assert.Equal(3, stackItems.Single(i => i.ProductId == 7).Amount);
}
public void OrderCreateValidator_Should_Fail_Validation_When_ObjectNumber_Null()
{
// arrange
var sut = new OrderCreateValidator();
var order = new OrderCreateRequest();
// act
var result = sut.Validate(order);
// assert
Assert.False(result.IsValid);
}
public async Task <IActionResult> createOrder([FromBody] OrderCreateRequest request)
{
try {
var orderId = await ordersService.createOrder(request);
return(Ok(orderId));
}
catch (UserNotFoundException e)
{
return(BadRequest("Wrong order data was passed"));
}
}
/// <summary>
/// 下单验证接口
/// </summary>
/// <param name="request"></param>
/// <param name="business"></param>
/// <returns></returns>
private PageResult VerifyOrder(OrderCreateRequest request, Tbl_OTABusiness business)
{
var orderInfo = request.Body.OrderInfo;
OrderCreateResponse result = new OrderCreateResponse
{
Head = HeadResult.V1,
Body = new OrderCreateInfo
{
Item = new List <OrderCreateItem>()
}
};
var validResult = _orderService.ValidDataForOrderVerifyRequest(request);
if (!validResult.Status)
{
result.Head.Code = validResult.Code;
result.Head.Describe = validResult.Message;
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
List <int> productIds = orderInfo.TicketList.Select(a => a.ProductId).ToList();
var ticketIds = _otaTicketRelationService.GetTicketIds(business.Id, productIds);
var tbl_Tickets = _ticketService.CheckIsTicketIds(ticketIds, business.ScenicId, orderInfo.VisitDate.ToDataTime());
var validDataResult = _orderService.ValidDataForOrderCreateRequest(request, tbl_Tickets);
if (!validDataResult.Status)
{
result.Head.Code = validDataResult.Code;
result.Head.Describe = validDataResult.Message;
result.Body.Item.Add(new OrderCreateItem
{
ProductId = request.Body.OrderInfo.TicketList[0].ProductId.ToString(),
useDate = request.Body.OrderInfo.VisitDate,
quantity = 0
});
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
result.Head.Code = "000000";
result.Head.Describe = "成功";
result.Body.OrderStatus = "OREDER_SUCCESS";
foreach (var row in tbl_Tickets)
{
result.Body.Item.Add(new OrderCreateItem
{
ProductId = row.TicketId.ToString(),
useDate = request.Body.OrderInfo.VisitDate,
quantity = 500000
});
}
return(PageDataResult.Data(result, business.Saltcode.ToString()));
}
public async Task <DataResponseObject <OrderDTO> > CreateOrder(OrderCreateRequest order)
{
var createdOrder = await _orderRepository.CreateOrder(_mapper.Map <Order>(order));
if (createdOrder.Success)
{
_logger.LogInformation("Creating order with id {ID} with timeout of 10s", createdOrder.Data.Id);
await _bus.Publish(new OrderCreatedEvent(createdOrder.Data.Id, createdOrder.Data.Price, createdOrder.Data.StockAmount, createdOrder.Data.UserId), optionalHeaders : new Dictionary <string, string> {
{ "x-message-ttl", "10000" }
});
}
return(_mapper.Map <DataResponseObject <OrderDTO> >(createdOrder));
}
public async Task CreateOrder_Should_Return_BadRequest_When_ObjectNumber_Is_Missing()
{
// arrange
var createdOrder = new OrderCreateRequest();
var httpClient = _testFixture.Factory.CreateClient();
var httpContent = new StringContent(JsonSerializer.Serialize(createdOrder), Encoding.UTF8, "application/json");
// act
var response = await httpClient.PostAsync("api/v1/orders", httpContent);
// assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task <int> createOrder(OrderCreateRequest request)
{
if (await dbContext.Client.Where(client => client.clientId == request.clientId).SingleOrDefaultAsync() != null)
{
var order = new Order
{
creationTime = DateTime.Now,
recipientName = request.recipientName,
recipientEmail = request.recipientEmail,
recipientPhoneNumber = request.recipientPhoneNumber,
recipientSurname = request.recipientSurname,
deliveryAddress = request.deliveryAddress,
deliveryType = request.deliveryType,
paymentType = request.paymentType,
realizationState = RealizationStateEnum.NotAccepted,
clientId = request.clientId
};
if (order.paymentType == PaymentTypeEnum.OnlinePayment)
{
order.realizationState = RealizationStateEnum.Accepted;
}
await dbContext.Order.AddAsync(order);
order.Products = new List <OrderProduct>();
foreach (OrderProductConnection orderProdcut in request.products)
{
var product = await dbContext.Product.Where(product => product.productId == orderProdcut.productId).SingleOrDefaultAsync();
if (product != null)
{
order.Products.Add(new OrderProduct {
orderId = order.orderId, productId = product.productId, amount = orderProdcut.amount
});
}
else
{
throw new ProductNotFoundException("no such user");
}
}
await dbContext.SaveChangesAsync();
return(order.orderId);
}
else
{
throw new UserNotFoundException("no such user");
}
}
public void OrderCreateValidator_Should_Pass_Validation_When_ObjectNumber_NotNull()
{
// arrange
var sut = new OrderCreateValidator();
var order = new OrderCreateRequest {
ObjectNumber = "B123",
};
// act
var result = sut.Validate(order);
// assert
Assert.True(result.IsValid);
}
public async Task <ApiResult <string> > Create(OrderCreateRequest request)
{
var json = JsonConvert.SerializeObject(request);
var httpContent = new StringContent(json, Encoding.UTF8, "application/json");
var response = await _client.PostAsync($"/api/orders", httpContent);
var result = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <ApiResultSuccess <string> >(result));
}
return(JsonConvert.DeserializeObject <ApiResultErrors <string> >(result));
}
public async Task <ActionResult <Order> > PostOrder([FromBody] OrderCreateRequest order)
{
try
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
var orderToBeAdded = await service.PostOrderAsync(order, userId);
return(CreatedAtAction(nameof(GetOrder), new { id = orderToBeAdded.orderId }, orderToBeAdded));
}
catch (Exception)
{
throw;
}
}
