public async Task <IActionResult> AddOrderForCustomer(string customerId, [FromBody] OrderForCreationDto model)
{
if (!await _orderService.CustomerExists(customerId))
{
return(NotFound("Customer Not Found!"));
}
var order = _mapper.Map <Order>(model);
var orderCreated = _mapper.Map <OrderDto>(await _orderService.AddAsync(order));
return(CreatedAtRoute("GetOrderForCustomer",
new { customerId, orderId = orderCreated.OrderID },
orderCreated));
}
public async Task <ActionResult <OrderDto> > CreateOrder(OrderDto orderDto)
{
Order order = orderDto.ToOrder();
await _orderService.AddAsync(order);
return(CreatedAtAction(nameof(GetOrder), new { orderId = order.Id }, order.ToOrderDto()));
}
public async Task <IHttpActionResult> PostOrder(OrderDto orderDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try {
Order order = new Order();
order.ClientId = orderDto.ClientId;
order.DateBegin = Convert.ToDateTime(orderDto.DateBegin);
order.PhoneNumber = orderDto.PhoneNumber;
order.StatusId = orderDto.StatusId;
order.Comment = orderDto.Comment;
order = await _orderService.AddAsync(order);
orderDto.Id = order.Id;
return(CreatedAtRoute("ApiRoute", new { id = orderDto.Id }, orderDto));
}
catch (DbUpdateConcurrencyException)
{
//Log something her...
return(InternalServerError());
}
}
public async Task <IActionResult> Post([FromBody] OrderInputModel orderInputmodel)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
foreach (var item in orderInputmodel.Items)
{
var product = await _productService.GetByIdAsync(item.ProductId);
product.AvailableProduct -= item.NoOfProduct;
if (!await CheckProductAvailablityAsync(item))
{
return(NotFound(product));
}
await _productService.UpdateAsync(product);
}
var result = await _orderService.AddAsync(orderInputmodel.Map(orderInputmodel));
return(Ok(result.OrderNumber));
}
catch (Exception ex)
{
_loggerManager.LogError(ex.StackTrace + ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task OnRecordEditConfirm()
{
#region 進行 Form Validation 檢查驗證作業
if (LocalEditContext.Validate() == false)
{
return;
}
#endregion
#region 檢查資料完整性
#endregion
if (IsShowEditRecord == true)
{
if (isNewRecordMode == true)
{
await CurrentService.AddAsync(mapper.Map <Order>(CurrentRecord));
dataGrid.RefreshGrid();
}
else
{
await CurrentService.UpdateAsync(mapper.Map <Order>(CurrentRecord));
dataGrid.RefreshGrid();
}
IsShowEditRecord = false;
}
}
public async Task <object> AddOrder([FromBody] OrderModel model)
{
if (model.ArrivalDate.ToUniversalTime() < DateTime.UtcNow ||
model.DepartureDate.ToUniversalTime() < model.ArrivalDate.ToUniversalTime().AddDays(1))
{
return(BadRequest("Incorrect arrival or departure date." + Environment.NewLine
+ "Note: earliest arrival date is today and you must book room for at least one day."));
}
var user = await _userManager.GetUserAsync(HttpContext.User);
if (user.IsRenter)
{
return(StatusCode(403, "You can't have two orders simultaneously"));
}
model.UserId = user.Id;
Order resultOrder = await _orderService.AddAsync(model);
if (resultOrder != null)
{
return(CreatedAtAction("AddOrder", resultOrder.Id));
}
else
{
return(NotFound("We have not found suitable room"));
}
}
public async Task <IActionResult> Post([FromBody] OrderDto data)
{
APIResult apiResult;
Order record = mapper.Map <Order>(data);
if (record != null)
{
var result = mapper.Map <OrderDto>(record);
var isSuccessful = await OrderService.AddAsync(record);
if (isSuccessful)
{
apiResult = APIResultFactory.Build(true, StatusCodes.Status201Created,
ErrorMessageEnum.None, payload: result);
}
else
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
ErrorMessageEnum.無法新增紀錄, payload: record);
}
}
else
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
ErrorMessageEnum.傳送過來的資料有問題, payload: data);
}
return(Ok(apiResult));
}
public async Task <ActionResult> AddAsync([FromBody] OrderDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string userId = getUserId();
if (userId == null)
{
return(Unauthorized("Authentication Information required."));
}
dto.Username = userId;
int orderId = 0;
try
{
orderId = await _orderService.AddAsync(dto);
}catch (KeyNotFoundException e)
{
return(NotFound(e.Message));
}
return(Created($"api/vi/order/{orderId}", orderId));
}
public async Task <IActionResult> Post([FromBody] OrderModel orderModel)
{
_iLogger.LogInformation($"Controller : {this.GetControllerName()} , Action {this.GetActionName()} : => Visited at {DateTime.UtcNow.ToLongTimeString()}");
var createdOrder = await _iOrderService.AddAsync(orderModel);
return(CreatedAtAction(nameof(GetById), new { id = createdOrder.Id }, createdOrder.Id));
}
public async Task <IActionResult> AddToCart([FromBody] Cart cart)
{
string userId = _userManager.GetUserId(User);
var orderId = await _orderService.AddAsync(cart, userId);
var response = await _orderDetailService.AddAsync(orderId, cart);
return(CreatedAtAction(nameof(AddToCart), response));
}
public async Task <IActionResult> Post([FromBody] Order order, int customerId)
{
if (await _orderService.AddAsync(order, customerId))
{
return(Ok());
}
return(BadRequest(order));
}
public async Task OnRecordEditConfirm()
{
#region 進行 Form Validation 檢查驗證作業
if (LocalEditContext.Validate() == false)
{
return;
}
#endregion
#region 檢查資料完整性
if (isNewRecordMode == true)
{
var checkedResult = await CurrentService
.BeforeAddCheckAsync(CurrentRecord);
if (checkedResult.Success == false)
{
MessageBox.Show("400px", "200px", "警告",
ErrorMessageMappingHelper.Instance.GetErrorMessage(checkedResult.MessageId));
thisRazorComponent.NeedRefresh();
return;
}
}
else
{
var checkedResult = await CurrentService
.BeforeUpdateCheckAsync(CurrentRecord);
if (checkedResult.Success == false)
{
MessageBox.Show("400px", "200px", "警告",
ErrorMessageMappingHelper.Instance.GetErrorMessage(checkedResult.MessageId));
thisRazorComponent.NeedRefresh();
return;
}
}
#endregion
if (IsShowEditRecord == true)
{
if (isNewRecordMode == true)
{
await CurrentService.AddAsync(CurrentRecord);
dataGrid.RefreshGrid();
}
else
{
await CurrentService.UpdateAsync(CurrentRecord);
dataGrid.RefreshGrid();
}
IsShowEditRecord = false;
}
}
public async Task <ActionResult <OrderDto> > PostAsync(OrderDto body)
{
var result = await _orderService.AddAsync(UserId, body);
if (result == null)
{
return(BadRequest());
}
return(Created($"{HttpContext.Request.Path}/{result.Id}", result));
}
public async Task <IActionResult> Post([FromBody] OrderInfo order)
{
if (order == null || order.Id != default(int))
{
return(BadRequest());
}
var newOrder = await orderService.AddAsync(order);
return(CreatedAtAction("Get", "Orders", new { id = newOrder.Id }, newOrder));
}
public async Task <ActionResult> Post([FromBody] OrderViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest());
}
var order = mapper.Map <Services.Dtos.Order>(model);
return(this.Created("", await orderService.AddAsync(order)));
}
public async Task <ServiceResult> Add([FromBody] OrderAddModel apiEntity)
{
var entity = OrderAddModel.Map(apiEntity);
var result = await _orderService.AddAsync(entity);
if (result.TryCastModel(out Order order))
{
result.ViewModel = OrderViewModel.Map(order);
}
return(result);
}
public async Task <IActionResult> PostBatchTask([FromBody] Order order)
{
if (!ModelState.IsValid)
{
_logger.Log(LogLevel.Error, $"Error {ModelState}");
return(BadRequest(ModelState));
}
order.OrderId = Guid.NewGuid();
order.CreatedAt = DateTime.UtcNow;
await _orderService.AddAsync(_cancellationService.GetToken(), order.OrderId, order.BatchCount, order.NumberPerBatch);
return(Ok(order));
}
public async Task <IActionResult> Post([FromBody] OrderDto data)
{
APIResult apiResult;
#region 驗證 DTO 物件的資料一致性
if (!ModelState.IsValid)
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
ErrorMessageEnum.傳送過來的資料有問題, payload: data);
return(Ok(apiResult));
}
#endregion
OrderAdapterModel record = mapper.Map <OrderAdapterModel>(data);
if (record != null)
{
var result = mapper.Map <OrderDto>(record);
#region 新增記錄前的紀錄完整性檢查
VerifyRecordResult verify = await OrderService.BeforeAddCheckAsync(record);
if (verify.Success == false)
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
ErrorMessageMappingHelper.Instance.GetErrorMessage(verify.MessageId),
payload: result);
return(Ok(apiResult));
}
#endregion
var verifyRecordResult = await OrderService.AddAsync(record);
if (verifyRecordResult.Success)
{
apiResult = APIResultFactory.Build(true, StatusCodes.Status201Created,
ErrorMessageEnum.None, payload: null);
}
else
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
verifyRecordResult.MessageId, payload: record);
}
}
else
{
apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK,
ErrorMessageEnum.傳送過來的資料有問題, payload: data);
}
return(Ok(apiResult));
}
public async Task <ApiResponse> AddOrder([FromBody] OrderPassDto obj)
{
try
{
if (obj.OrderDto.UserId != Guid.Empty)
{
var userId = await _userService.GetByIdAsync(obj.OrderDto.UserId);
if (userId == null)
{
return(new ApiResponse("Không tồn tại khách hàng", 400));
}
var order = _mapper.Map <Order>(obj.OrderDto);
await _orderService.AddAsync(order);
if (order != null)
{
//var newOrderDetails = new List<OrderDetailDto>();
foreach (var or in obj.OrderDetailDtos)
{
var product = await _productService.GetByIdAsync(or.ProductId);
or.OrderId = order.Id;
}
var orderDetails = _mapper.Map <List <OrderDetail> >(obj.OrderDetailDtos);
await _orderDetailService.AddManyAsync(orderDetails);
//return new ApiResponse($"Success", 201);
userId.AccumulatedPoints = userId.AccumulatedPoints - order.AccumulatedPoints;
if (userId.AccumulatedPoints >= 0)
{
await _userService.UpdateAsync(userId);
}
else
{
return(new ApiResponse("Lỗi", 404));
}
}
var vm = _mapper.Map <OrderViewModel>(order);
return(new ApiResponse("success", vm, 200));
}
return(new ApiResponse("not found user", 404));
}
catch (Exception ex)
{
return(new ApiResponse($"{ex}", 400));
}
}
public async Task HandleAsync(CreateOrder command)
{
Console.WriteLine($"Creating Order for UserId {command.UserId} at restaurant {command.RestaurantId}");
try
{
await _orderService.AddAsync(command.Id, command.UserId, command.RestaurantId, command.Items, command.Status, command.CreatedAt);
await _busClient.PublishAsync(new OrderCreated(command.Id, command.UserId, command.RestaurantId, command.Items, command.Status, command.CreatedAt));
return;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public JsonResult AddNewOrder(OrderViewModel model)
{
string output = "Error";
model.Username = User.Identity.Name;
if (ModelState.IsValid)
{
Task <bool> result = _orderService.AddAsync(model);
if (result.Result)
{
output = "Success";
}
}
return(Json(output, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Create([FromBody] OrderResource orderResource)
{
if (orderResource == null)
{
orderResource = new OrderResource();
}
var order = _mapper.Map <OrderResource, Order>(orderResource);
var result = await _orderService.AddAsync(order);
if (!result.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> AcceptOrder()
{
if (!(User.IsInRole("Customer") || User.IsInRole("Admin")))
{
return(RedirectToAction("Index", "Home"));
}
var user = userService.GetUser(HttpContext.User.Identity.Name);
var items = await shoppingCardService.GetItemsFromBox(userManager.GetUserId(HttpContext.User));
var address = JsonConvert.DeserializeObject <ItemToPostAddress>((string)TempData["AddressData"]);
Order order = new Order
{
Status = 2,
UserId = user.Id,
DateAccept = DateTime.Now.ToLocalTime()
};
foreach (var item in items)
{
item.Status = 2;
}
;
OrderAddress orderAddress = new OrderAddress
{
UserId = user.Id,
City = address.City,
Email = address.Email,
Name = address.Name,
Surname = address.Surname,
PhoneNumber = address.PhoneNumber,
Street = address.Street,
PostalCode = address.PostalCode
};
await orderService.AddAsync(order, orderAddress, items);
return(Json(new
{
newUrl = "/Home"
}));
}
public async Task <ActionResult <OrderReadDto> > Post([FromBody] OrderCreateDto orderCreateDto)
{
orderCreateDto.ReaderId = User.GetUserId();
OrderReadDto newOrder = _mapper.Map <OrderReadDto>(
await _orderService.AddAsync(_mapper.Map <Order>(orderCreateDto))
);
Book book = await _bookService.ToggleAvailability(newOrder.BookId);
await _notificationsService.OrderBook(new BookDto
{
Author = (await _bookService.GetByIdAsync(book.Id)).Author.Name,
Title = book.Title
});
return(CreatedAtAction("Get", new { id = newOrder.Id }, newOrder));
}
public async Task <int> AddOrder(int isPay, OrderDto model)
{
var result = await _service.AddAsync(new Order()
{
OrderId = model.OrderId,
ProductId = model.ProductId,
Quantity = model.Quantity,
UnitPrice = model.UnitPrice
});
if (result == 1 && isPay == 1)
{
IProductService service = new ProductService();
var product = await service.QueryAsync(model.ProductId);
product.ProductNumber -= Convert.ToInt32(model.Quantity);
return(await service.EditAsync(product));
}
return(result);
}
public async Task <IActionResult> Create([FromBody, CustomizeValidator] OrderToAdd order, CancellationToken cancellationToken = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var isEmailConf = await _userService.IsEmailConfirmedAsync(HttpContext.User.Claims.Single(_ => _.Type == "id").Value);
if (isEmailConf.IsSuccess)
{
var result = await _orderService.AddAsync(order, HttpContext.User.Claims.Single(_ => _.Type == "id").Value, cancellationToken);
if (result.IsError)
{
throw new InvalidOperationException(result.Message);
}
await _notificationHubContext.Clients.All.SendAsync("New order!", cancellationToken);
return((IActionResult)Ok(result.Data));
//return result.IsError ? throw new InvalidOperationException(result.Message) : (IActionResult)Ok(result.Data);
}
else
{
return(StatusCode(StatusCodes.Status403Forbidden));
}
}
catch (InvalidOperationException ex)
{
Log.Error(ex, ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError, new CustumResult()
{
Status = StatusCodes.Status500InternalServerError, Message = ex.Message
}));
}
}
protected override async Task <GetOrderDto> ExecuteAsync(CreateOrderCommand request, CancellationToken ct)
{
AddOrderDto orderDto = _mapper.Map <AddOrderDto>(request);
return(await _orderService.AddAsync(orderDto, ct));
}
public async Task <IActionResult> CreateOrder(CreateOrderDTO order)
{
order.UserId = _userManager.GetUserId(User);
return(Ok(await _orderService.AddAsync(order)));
}
public async Task <IActionResult> CheckOutAsync(
[Required]
string deliveryAddress,
[Required]
DateTime deliveryDateTime
)
{
var currentBasket = HttpContext.Session?.GetObjectFromJson <BasketViewModel>("basket");
var currentBasketItemList = currentBasket?.BasketItems?.ToList();
if (currentBasketItemList == null)
{
return(BadRequest("Giỏ hàng trống"));
}
var buyer = await _currentBuyerService.GetInformation(User);
if (buyer == null)
{
return(BadRequest("Bạn cần đăng nhập để có thể thanh toán"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Thông tin không được bỏ trống"));
}
var order = await _orderService.AddAsync(new Order
{
Status = OrderStatus.New,
DeliveryDate = deliveryDateTime,
DeliveryAddress = deliveryAddress,
CustomerId = buyer.Id,
TotalPrice = currentBasket.TotalPrice,
OrderDetails = currentBasket.BasketItems.Select(ele => new OrderDetail
{
ItemId = ele.ItemId,
Price = ele.Price,
Quantity = ele.Amount,
IsCombo = ele.IsCombo,
}).ToList(),
});
if (order != null)
{
List <Product> listProduct = await GetAllDistincProducts();
foreach (Product p in listProduct)
{
var updateStorage = await _storageRepository.AddAsync(
new Storage
{
ProductId = p.Id,
Quantity = p.Quantity,
DateChange = DateTime.Now
});
}
HttpContext.Session?.SetObjectAsJson("basket", null);
return(PartialView("_Basket", null));
}
return(BadRequest("Something not right right"));
}
public async Task <IActionResult> Save(OrderDto orderDto)
{
var orderSave = await _orderService.AddAsync(_mapper.Map <Order>(orderDto));
return(Created(string.Empty, _mapper.Map <OrderDto>(orderSave)));
}
