// Létrehozás public async Task <OrderItemDto> CreateOrderItemAsync(OrderItemDto orderItemDto) { OrderItem orderItem = mapper.Map <OrderItem>(orderItemDto); var result = await orderItemRepository.CreateOrderItem(orderItem); return(mapper.Map <OrderItemDto>(result)); }
public async Task <ActionResult> Put(int id, [FromBody] OrderItemDto oinew) { try { var oiWaitingForUpdate = _context.OrderItems.SingleOrDefault(p => p.OrderItemId == id); if (oiWaitingForUpdate == null) { return(NotFound()); } // modositasok elvegzese if (oinew.Amount != 0) { oiWaitingForUpdate.Amount = oinew.Amount; } if (oinew.StatusId != 0) { oiWaitingForUpdate.StatusId = oinew.StatusId; } // mentes az adatbazisban await _context.SaveChangesAsync(); return(Ok()); } catch (Exception ex) { return(StatusCode(418, ex.Message)); } }
public static OrderItemDto CreteOrderItem(string urlTargetSite, int orderId, int itemId, int quantity) { var url = $"{urlTargetSite}/api/OrderItems"; var oOrderItemDto = new OrderItemDto { OrderId = orderId, ItemId = itemId, Quantity = quantity }; var jsonString = JsonConvert.SerializeObject(oOrderItemDto); var httpContent = new StringContent(jsonString, Encoding.UTF8, "application/json"); using (HttpClient client = new HttpClient()) { using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result) { using (HttpContent content = response.Content) { var json = content.ReadAsStringAsync().Result; var model = JsonConvert.DeserializeObject <OrderItemDto>(json); return(model); } } } }
protected void ucIDetail_ChildListInstanceRowSaving(object sender, InstanceRowSavingEventArgs e) { using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey)) { switch ((InstanceTypes)Enum.Parse(typeof(InstanceTypes), e.InstanceType)) { case InstanceTypes.OrderItem: OrderFacade facade = new OrderFacade(uow); OrderItemDto orderItemDto = e.Instance as OrderItemDto; // Save data IFacadeUpdateResult <OrderData> result = facade.SaveOrderItem(CurrentInstance.Id, orderItemDto); e.IsSuccessful = result.IsSuccessful; if (result.IsSuccessful) { // Refresh OrderDto savedParentInstance = result.ToDto(new OrderConverter()); CurrentInstance.OrderItems = savedParentInstance.OrderItems; } else { // Deal with Update result ProcUpdateResult(result.ValidationResult, result.Exception); } break; } } }
internal IFacadeUpdateResult <OrderData> SaveOrderItem(object parentId, OrderItemDto childDto) { ArgumentValidator.IsNotNull("parentId", parentId); ArgumentValidator.IsNotNull("childDto", childDto); FacadeUpdateResult <OrderData> result = new FacadeUpdateResult <OrderData>(); IOrderService service = UnitOfWork.GetService <IOrderService>(); var parentQuery = service.Retrieve(parentId); if (parentQuery.HasResult) { Order parent = parentQuery.ToBo <Order>(); OrderItem child = RetrieveOrNewOrderItem(parent, childDto.Id); if (child != null) { child.ItemDescription = childDto.ItemDescription; child.ProductId = childDto.ProductId; child.ProductName = childDto.ProductName; child.UnitPrice = childDto.UnitPrice; child.QtyOrdered = childDto.QtyOrdered; child.Amount = childDto.Amount; var saveQuery = service.Save(parent); result.Merge(saveQuery); result.AttachResult(parent.RetrieveData <OrderData>()); } else { AddError(result.ValidationResult, "OrderItemCannotBeFound"); } } return(result); }
public OrderDto CreatePreOrder(SysUser sysUser, [FromForm] ProductPo productPo) { //1.创建订单号 string orderSn = OrderUtil.GetOrderCode(); //2.计算总价 decimal itemTotalPrice = productPo.ProductCount * productPo.ProductPrice; //3.创建订单项 OrderItemDto orderItemDto = new OrderItemDto(); orderItemDto.OrderSn = orderSn; orderItemDto.ProductId = productPo.ProductId; orderItemDto.ItemCount = productPo.ProductCount; orderItemDto.ItemPrice = productPo.ProductPrice; orderItemDto.ItemTotalPrice = itemTotalPrice; //4.创建订单 OrderDto orderDto = new OrderDto(); orderDto.UserId = sysUser.UserId; orderDto.OrderItemDtos = new List <OrderItemDto>() { orderItemDto }; return(orderDto); }
public IActionResult Post([FromBody] OrderItemDto model) { if (!TryValidateModel(model)) { return(BadRequest(ModelState)); } OrderItem item; if (model.Id.HasValue) { item = _db.OrderItem.FirstOrDefault(x => x.Id == model.Id); } else { item = new OrderItem { OrderId = model.OrderId }; _db.Add(item); } item.Count = model.Count; item.Price = model.Price; item.Product = model.Product; _db.SaveChanges(); return(Ok()); }
public int InsertOrderItem(OrderItemDto dto) { //string sql = @" INSERT INTO [dbo].[OrderItem]( [OrderId], [ProductId], [FeatureName],[FeatureValue], [Num], [Name], [TotalFee], [Price], [Sort], [Status], [Creator], [CreateTime], [IsDeleted] ) Select @OrderId, s.ProductId, f.Name , v.Value,@Num,p.Name,@TotalFee,@Price, 0, 1, NULL, @date, 0 from dbo.[Product] p join dbo.[ProductSku] s on p.id = s.Productid JOIN dbo.[FeatureValue] v on s.FeatureValueId = v.Id JOIN dbo.[Feature] f ON f.id = v.FeatureId Where p.Status =1 and Isdeleted = 0 "; string sql = @" INSERT INTO [dbo].[OrderItem]( [OrderId], [ProductId], [FeatureName],[FeatureValue], [Num], [Name], [TotalFee], [ImgUrl], [Price], [Sort], [Status], [Creator], [CreateTime], [IsDeleted] ) select @OrderId, @ProductId, @FeatureName , @FeatureValue,@Num, @Name,@TotalFee, p.CoverUrl, @Price, 0, 1, NULL, @date, 0 from dbo.[Product] p where p.Id=@ProductId;"; return(DbManage.Execute(sql, new { OrderId = dto.OrderId, ProductId = dto.ProductId, FeatureName = dto.FeatureName, FeatureValue = dto.FeatureValue, Num = dto.Num, Name = dto.Name, TotalFee = dto.TotalFee, Price = dto.Price, date = DateTime.Now })); }
public async Task Update(OrderItemDto orderItemDto) { var orderItem = ObjectMapper.Map <Models.OrderItem>(orderItemDto); //Get last orderItem quantity, we use this to update the product stock. var originalOrderItem = await _repository.GetAsync(orderItem.Id); int originalQuantity = 0; if (originalOrderItem != null) { originalQuantity = originalOrderItem.Quantity; } await _repository.UpdateAsync(orderItem); var product = await _productAppService.GetById(orderItem.ProductId); if (product != null && originalQuantity != orderItem.Quantity) { if (originalQuantity > orderItem.Quantity) { //The original quantity was higher so we must readd some of the stock product.Stock += (originalQuantity - orderItem.Quantity); } else { product.Stock += (orderItem.Quantity - originalQuantity); } await _productAppService.UpdateStock(product.Stock, product.Id); } return; }
public async Task <OrderItemDto> UpdateOrderItemAsync(OrderItemDto orderItem) { var existing = await this._dbContext.OrderItems.FirstOrDefaultAsync(x => x.OrderId == orderItem.OrderId && x.ProductId == orderItem.ProductId); if (existing != null) { if (orderItem.Quantity.HasValue) { existing.Quantity = orderItem.Quantity.Value; } if (!string.IsNullOrEmpty(orderItem.Note)) { existing.Note = orderItem.Note; } else if (orderItem.Note == string.Empty) { existing.Note = null; } await this._dbContext.SaveChangesAsync(); return(orderItem); } return(null); }
public async Task <IHttpActionResult> AddOrderItemToOrder(int orderId, OrderItemDto orderItem) { var order = _db.Orders.First(o => o.Id == orderId); if (order == null) { return(StatusCode(HttpStatusCode.NoContent)); } order.UpdateOrderItem(new OrderItem(GetProductOptionById(orderItem.ProductOptionId), orderItem.Quantity)); try { await _db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!OrderExists(orderId)) { return(StatusCode(HttpStatusCode.NoContent)); } else { throw; } } return(StatusCode(HttpStatusCode.NoContent)); }
public async Task <ActionResult> Post([FromBody] OrderItemDto oinew) { try { OrderItem oi = _mapper.Map <OrderItem>(oinew); var orderIdCheck = _context.Orders.Where(p => p.OrderId == oinew.OrderId); var productIdCheck = _context.Products.Where(p => p.ProductID == oinew.ProductID); if (orderIdCheck == null) { return(NotFound()); } if (productIdCheck == null) { return(NotFound()); } // Mivel új dolog, ezért instant 1 lesz. oi.StatusId = 1; _context.OrderItems.Add(oi); await _context.SaveChangesAsync(); return(Ok()); } catch (Exception ex) { return(StatusCode(418, ex.Message)); } }
public async Task <CustomResponse> Update(Guid id, UpdateOrderItemModel UpdateRequest) { OrderItemDto orderItemDto = _unitOfWork.OrderItemRepository.Find(id); if (orderItemDto == null) { return(_responsMessages.OrderItemNotFound); } if (orderItemDto.Order.OrderStatus != OrderStatus.New) { return(_responsMessages.InvalidOperation); } orderItemDto.Order.Total -= orderItemDto.Total; orderItemDto.Quantity = UpdateRequest.Quantity; orderItemDto.Total = orderItemDto.Quantity * orderItemDto.PricePerUnit; orderItemDto.Order.Total += orderItemDto.Total; if (orderItemDto.Quantity > orderItemDto.Item.Quantity) { return(_responsMessages.InvalidOrderItemQuantity); } await _unitOfWork.SaveChangesAsync(); return(_responsMessages.OrderItemQuantityUpdatedSuccessfully); }
public async Task <OrderItemDto> CreateAsync(OrderItemDto orderItem) { string jsonRequest = serializer.Serialize(orderItem); string requestUri = Properties.Resources.UrlToServer + "OrderItem/Create"; try { var responseMessage = await client.PostAsync(requestUri, new StringContent(jsonRequest, Encoding.UTF8, "application/json")); if (responseMessage.IsSuccessStatusCode) { string jsonResult = await responseMessage.Content.ReadAsStringAsync(); orderItem = serializer.Deserialize <OrderItemDto>(jsonResult); } else { orderItem = null; } return(orderItem); } catch (HttpRequestException ex) { if (!NetworkInterface.GetIsNetworkAvailable()) { throw new NoInternetConnectionException("No internet connection, please try again later."); } throw ex; } }
public async Task <int> UpdateItem(int orderId, OrderItemDto item) { OrderProducts entity = mapper.Map <OrderProducts>(item); entity.OrderId = orderId; return(await repository.UpdateItem(entity)); }
/// <summary> /// Обновляет состояние позиции заказа при редактировании заказа. /// </summary> /// <param name="order">Заказ.</param> /// <param name="itemDto">Транспортная модель позиции заказа.</param> private async Task UpdateOrderItem(Order order, OrderItemDto itemDto) { if (order == null || itemDto == null) { return; } switch (itemDto?.Action) { case Contracts.Enums.ChangeStateEnum.Add: await AddItemToOrder(order, itemDto); break; case Contracts.Enums.ChangeStateEnum.ChangeQuantity: ChangeItemQuantityInOrder(order, itemDto); break; case Contracts.Enums.ChangeStateEnum.Delete: RemoveItemFromOrder(order, itemDto); break; default: throw new Exception("Не задано или неправильное значение ChangeStateEnum"); } }
public async Task UpdateItemQuantity_WithExistingItem_ReturnOrderWithItemsCollection() { //Arrange SetupOrderWithItem(); var orderService = new OrderService(_uow.Object, _UserRepo.Object, _ItemRepo.Object, _OrderRepo.Object); var ItemToAdd = new OrderItemDto { ItemId = ItemId, Quantity = 2 }; //Act await orderService.AddItem(OrderId, ItemToAdd); ItemToAdd.Quantity = 5; var updatedOrder = await orderService.AddItem(OrderId, ItemToAdd); //Assert Assert.AreEqual(100, updatedOrder.Total); }
public async Task <IActionResult> Put([FromRoute] int id, [FromBody] OrderItemDto data) { APIResult apiResult; var record = await OrderItemService.GetAsync(id); if (record != null) { OrderItem recordTarget = mapper.Map <OrderItem>(data); recordTarget.OrderItemId = id; var result = mapper.Map <OrderItemDto>(recordTarget); var isSuccessful = await OrderItemService.UpdateAsync(recordTarget); if (isSuccessful) { apiResult = APIResultFactory.Build(true, StatusCodes.Status202Accepted, ErrorMessageEnum.None, payload: result); } else { apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK, ErrorMessageEnum.無法修改紀錄, payload: result); } } else { apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK, ErrorMessageEnum.沒有任何符合資料存在, payload: data); } return(Ok(apiResult)); }
public async Task <IActionResult> Post([FromBody] OrderItemDto data) { APIResult apiResult; OrderItem record = mapper.Map <OrderItem>(data); if (record != null) { var result = mapper.Map <OrderItemDto>(record); var isSuccessful = await OrderItemService.AddAsync(record); if (isSuccessful) { apiResult = APIResultFactory.Build(true, StatusCodes.Status201Created, ErrorMessageEnum.None, payload: result); } else { apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK, ErrorMessageEnum.無法新增紀錄, payload: result); } } else { apiResult = APIResultFactory.Build(false, StatusCodes.Status200OK, ErrorMessageEnum.傳送過來的資料有問題, payload: data); } return(Ok(apiResult)); }
public PageResult <OrderItemDto> GetByOrderNo(string orderNo, int pageIndex, int pageSize) { using (var db = new YintaiHZhouContext()) { IQueryable <OrderItem> query = db.OrderItems.Where(t => t.OrderNo == orderNo); IQueryable <OPC_RMADetail> query2 = db.OrderItems.Where(t => t.OrderNo == orderNo) .Join(db.OPC_RMADetails, t => t.Id, o => o.OrderItemId, (t, o) => o); var filter = from q in query join b in db.Brands on q.BrandId equals b.Id into cs join rmaDetail in query2 on q.Id equals rmaDetail.OrderItemId into rma select new { Order = q, Brand = cs.FirstOrDefault(), Rma = rma.FirstOrDefault() }; filter = filter.OrderByDescending(t => t.Order.CreateDate); var list = filter.ToPageResult(pageIndex, pageSize); IList <OrderItemDto> lstDtos = new List <OrderItemDto>(); foreach (var t in list.Result) { OrderItemDto o = Mapper.Map <OrderItem, OrderItemDto>(t.Order); o.BrandName = t.Brand == null ? "" : t.Brand.Name; if (t.Rma != null) { o.NeedReturnCount = t.Order.Quantity - t.Rma.BackCount; o.ReturnCount = t.Rma.BackCount; } lstDtos.Add(o); } return(new PageResult <OrderItemDto>(lstDtos, list.TotalCount)); } }
private async void UpdateOrderItem(OrderItemDto item) { loading = true; try { var updateItem = JsonSerializer.Deserialize <OrderItemChangeDto>( JsonSerializer.Serialize <OrderItemDto>(item)); var res = await _ordersDataService.UpdateOrderItem(item.Id, updateItem); // Success if (res.StatusCode == System.Net.HttpStatusCode.NoContent) { await setCart.GetOrder(); } // Error else { await _helpers.ErrorResponse(res); } } catch (AccessTokenNotAvailableException e) { e.Redirect(); } catch (Exception e) { _state.err = new Error(e.Message, false); } loading = false; StateHasChanged(); }
private void btnSendToAccess_Click(object sender, EventArgs e) { Process[] process = Process.GetProcessesByName("MSACCESS"); if (process.Length == 0) { MessageBox.Show("Access не запущен", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return; } if (process.Length > 1) { string message = "Запущено несколько копий MS Access" + Environment.NewLine + "Чтобы избежать проблем, закройте лишниее копии и попробуйте снова."; MessageBox.Show(message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return; } string path = "c:\\Export\\Zakaz\\Zakaz.csv"; StreamWriter sw; try { sw = new StreamWriter(new FileStream(path, FileMode.Create), Encoding.Default); } catch (IOException ex) { string message = "Произошла ошибка при обращении к файлу с заказом:" + Environment.NewLine + ex.Message + Environment.NewLine + "Закройте все программы, которые могут его использовать и попробуйте снова"; MessageBox.Show(message, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return; } sw.WriteLine("НомерСтроки;НаимТовара;Количество;Цена;Сумма;КодКлиента;КодТовара;КодСтрокПрихода;Дата;НаимКлиента;Примечание"); int n = 0; foreach (ListViewItem item in lvOrderItems.Items) { OrderItemDto orderItemDto = item.Tag as OrderItemDto; sw.WriteLine(string.Format("{0};{1};{2};{3};{4};{5};{6};{7};{8};{9};{10}", ++n, orderItemDto.Name, orderItemDto.Count, orderItemDto.Price, orderItemDto.Price * orderItemDto.Count, currentOrder.ClientId, orderItemDto.ProductId, orderItemDto.ReceiptId, DateTime.Now, currentOrder.ClientName, "")); } sw.Close(); Application application = Marshal.GetActiveObject("Access.Application") as Application; // Run the macros. RunMacro(application, new Object[] { "ExportZakaz" }); }
public PageResult <OrderItemDto> GetOrderItemsAutoBack(string orderNo, int pageIndex, int pageSize) { using (var db = new YintaiHZhouContext()) { IQueryable <OrderItem> query = db.OrderItems.Where(t => t.OrderNo == orderNo); var filter = from q in query join b in db.Brands on q.BrandId equals b.Id into cs select new { Order = q, Brand = cs.FirstOrDefault() }; filter = filter.OrderByDescending(t => t.Order.CreateDate); var list = filter.ToPageResult(pageIndex, pageSize); IList <OrderItemDto> lstDtos = new List <OrderItemDto>(); foreach (var t in list.Result) { OrderItemDto o = Mapper.Map <OrderItem, OrderItemDto>(t.Order); o.BrandName = t.Brand == null ? "" : t.Brand.Name; o.NeedReturnCount = t.Order.Quantity; o.ReturnCount = t.Order.Quantity; lstDtos.Add(o); } return(new PageResult <OrderItemDto>(lstDtos, list.TotalCount)); } }
public void Update(OrderItemDto item) { OrderItem convertedOrder = Mapper.Map <OrderItemDto, OrderItem>(item); orderItemRepository.Update(convertedOrder); orderItemRepository.Save(); }
public async Task <OrderItemDto> GetOrderItemAsync(int id) { OrderItemDto orderItem = null; string requestUri = Properties.Resources.UrlToServer + "OrderItem/GetOrderItem/" + id; try { var responceMessage = await client.GetAsync(requestUri); if (responceMessage.IsSuccessStatusCode) { string jsonResult = await responceMessage.Content.ReadAsStringAsync(); orderItem = serializer.Deserialize <OrderItemDto>(jsonResult); } return(orderItem); } catch (HttpRequestException ex) { if (!NetworkInterface.GetIsNetworkAvailable()) { throw new NoInternetConnectionException("No internet connection, please try again later."); } throw ex; } }
internal static OrderItem ToOrderItem(this OrderItemDto itemDto) { return(new OrderItem() { Price = itemDto.Price, Name = itemDto.Name, }); }
public async Task Delete(OrderItemDto orderItem) { using (UnitOfWorkProvider.Create()) { _OrderItemService.DeleteProduct(orderItem.Id); await UnitOfWorkProvider.GetUnitOfWorkInstance().Commit(); } }
public IActionResult Post([FromBody] OrderItemDto orderItemDto) { var orderItem = _mapper.Map <OrderItem>(orderItemDto); var createdOrderItem = _orderItemService.Create(orderItem); var createdOrderItemDto = _mapper.Map <OrderItemDto>(createdOrderItem); return(StatusCode((int)HttpStatusCode.Created, createdOrderItemDto)); }
public OrderItemDto GetOrderItem(int id) { OrderItem orderItem = orderItemRepository.GetItem(id); OrderItemDto dto = Mapper.Map <OrderItem, OrderItemDto>(orderItem); orderItem = Mapper.Map <OrderItemDto, OrderItem>(dto); return(dto); }
public void Update(OrderItemDto order) { var ord = new OrderItem(); mapper.Map(order, ord); unitOfWork.OrderItemRepository.Edit(ord); unitOfWork.Save(); }