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