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))); }