//展示信息
public async Task <OrderEditDto> GetOrderForEditAsync(NullableIdDto input)
{
//查询供应商，并展示供应商
var suppliers = await _supplierReository.GetAll().ProjectTo <SupplierListDto>().ToListAsync();
if (input.Id.HasValue)//编辑
{
var order = await _purchaseOrderRepository.GetAsync(input.Id.Value);
var orderDetail = await _purchaseOrderDetailRepository.GetAll().Where(x => x.OrderCode.Equals(order.Code)).ProjectTo <PurchaseOrederDeListDto>().ToListAsync();
var dto = new OrderEditDto
{
Id = order.Id,
Code = order.Code,
PurOrderDet = orderDetail,
Suppliers = suppliers,
SupplierId = order.SupplierId
};
return(dto);
}
else//添加
{
return(new OrderEditDto()
{
Suppliers = suppliers,
});
}
}
public void EditOrder(OrderEditDto orderEditDto, bool changeOneToMany = false)
{
if (changeOneToMany)
{
List <OrderBox> orderBoxes = SnHelper.GetListboxNumber(orderEditDto.SnMin, orderEditDto.OnLineQuantity).Select(item => new OrderBox()
{
//设置外键Id
OrderId = orderEditDto.OrderId,
//盒号
BoxNumber = item,
//新建时间
OrderBoxCreateTime = DateTime.Now
}).ToList();
var editEntity = _mapper.Map <OrderPlacing>(orderEditDto);
//editEntity.OrderBoxes = orderBoxes;
_orderBoxRepository.DelOrderBox(editEntity.OrderId);
_orderBoxRepository.AddOrderAllBoxes(orderBoxes);
_orderRepository.Update(editEntity);
_unitOfWork.SaveChanges();
}
else
{
var editEntity = _mapper.Map <OrderPlacing>(orderEditDto);
_orderRepository.Update(editEntity);
_unitOfWork.SaveChanges();
}
}
public async Task <ActionResult> AddOrderAsync(OrderEditDto order)
{
var orderBaseInfo = this._mapper.Map <OrderEntity>(order);
var orderItems = this._mapper.Map <IEnumerable <OrderItemEntity> >(order.OrderItems);
using (var transaction = this._ctx.Database.BeginTransaction())
{
try
{
await this._ctx.Orders.AddAsync(orderBaseInfo);
orderBaseInfo.Transaction = transaction.TransactionId.ToString();
await this._ctx.SaveChangesAsync();
foreach (var item in orderItems)
{
item.OrderID = orderBaseInfo.ID;
item.Transaction = transaction.TransactionId.ToString();
}
await this._ctx.OrderItems.AddRangeAsync(orderItems);
await this._ctx.SaveChangesAsync();
await transaction.CommitAsync();
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
await transaction.RollbackAsync();
}
}
return(Ok());
}
public async Task <IActionResult> PostOrderAsync([FromBody] OrderEditDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(await _orders.PostOrderAsync(model)));
}
protected virtual async Task <OrderEditDto> CreateOrderAsync(OrderEditDto input)
{
//TODO:新增前的逻辑判断，是否允许新增
var entity = ObjectMapper.Map <Order>(input);
entity = await _orderRepository.InsertAsync(entity);
return(entity.MapTo <OrderEditDto>());
}
/// <summary>
/// 编辑Order
/// </summary>
protected virtual async Task Update(OrderEditDto input)
{
//TODO:更新前的逻辑判断，是否允许更新
var entity = await _orderRepository.GetAsync(input.Id);
input.MapTo(entity);
// ObjectMapper.Map(input, entity);
await _orderRepository.UpdateAsync(entity);
}
public async Task UpdateOrder(OrderEditDto input)
{
var entity = await _orderManager.QueryAsNoTracking
.Where(o => o.Id == input.Id)
.FirstOrDefaultAsync();
entity.Status = input.Status;
entity.ProductIndate = input.ProductIndate;
entity.OrderSourceType = input.OrderSourceType;
await _orderManager.Update(entity);
}
public async Task <IActionResult> PutOrderAsync([FromRoute] string id, [FromBody] OrderEditDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var order = await _orders.PutOrderAsync(id, model);
if (order == null)
{
return(BadRequest(ModelState));
}
return(Ok(order));
}
public async Task <ActionResult> UpdateOrderAsync(OrderEditDto order)
{
var oriOrder = await this._ctx.Orders.FindAsync(order.OrderID);
if (oriOrder == null)
{
return(NotFound());
}
using (var transaction = this._ctx.Database.BeginTransaction())
{
try
{
this._mapper.Map(order, oriOrder);
// remove exclude
var orderItemIds = order.OrderItems.Select(p => p.OrderItemID);
var removeOrderItems = this._ctx.OrderItems.Where(p => p.OrderID == oriOrder.ID && orderItemIds.Contains(p.ID));
this._ctx.OrderItems.RemoveRange(removeOrderItems);
// new add
var newOrderItems = order.OrderItems.Where(p => p.OrderItemID == 0);
var dbOrderItems = this._mapper.Map <OrderItemEntity>(newOrderItems);
await this._ctx.OrderItems.AddRangeAsync(dbOrderItems);
// update
var needUpdateOrderItems = order.OrderItems.Except(newOrderItems);
foreach (var item in needUpdateOrderItems)
{
var tmp = await this._ctx.OrderItems.FindAsync(item.OrderItemID);
this._mapper.Map(item, tmp);
}
await this._ctx.SaveChangesAsync();
await transaction.CommitAsync();
return(Ok());
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
await transaction.RollbackAsync();
return(BadRequest(new { Err = ex.Message }));
}
}
}
public async Task <OrderEditDto> PostOrderFromSite(OrderEditDto model)
{
var order = new Order();
Mapper.Map(model, order);
order.ManagerId = "63ba12d8-cdda-4fd0-b7bf-c10f08e0d044";
order.Manager = null; // патч щоб не створювало фантомних користувачів
var product = await _context.Products.SingleOrDefaultAsync(w => w.Article == "000001");
order.OrderLines.Add(new OrderLine
{
OrderId = order.Id,
ProductId = product.Id,
UnitPrice = product.Price,
Quantity = 1
});
//add details
//model.OrderLines.ToList().ForEach(async detailDto =>
//{
// var detail = new OrderLine();
// var product = await _context.Products.SingleOrDefaultAsync(w => w.Article == detailDto.ProductArticle);
// detail.OrderId = order.Id;
// detail.ProductId = product.Id;
// detail.UnitPrice = product.SellingPrice;
// detail.Quantity = detailDto.Quantity;
// order.OrderLines = new List<OrderLine> { detail };
//});
order.OrderNumber = GetOrderNumber();
order.DateCreated = DateTime.Now;
order.Status = OrderStatus.New;
_context.Orders.Add(order);
await _context.SaveChangesAsync();
return(await GetOrderAsync(order.Id));
}
public async Task <OrderEditDto> PostOrderAsync(OrderEditDto model)
{
var order = new Order();
Mapper.Map(model, order);
await _activityLog.Post(model.Id, ActivityType.Create);
order.ManagerId = Utilities.GetUserId(_httpContextAccessor.HttpContext.User);
order.Manager = null; // патч щоб не створювало фантомних користувачів
if (order.DeliveryDate <= DateTime.Now)
{
_logger.LogWarning(LoggingEvents.UpdateItemError, "Неможливо вибрати дану дату доставки, дата раніша можливої відправки");
order.DeliveryDate = DateTime.Now.AddDays(1); //автоматично додати один день до сьогоднішньої дати, але потрабно показати повідомлення
}
//add details
model.OrderLines.ToList().ForEach(detailDto =>
{
var detail = new OrderLine();
var product = _context.Products.SingleOrDefault(w => w.Article == detailDto.ProductArticle);
detail.OrderId = order.Id;
detail.ProductId = product.Id;
detail.UnitPrice = product.Price;
detail.Quantity = detailDto.Quantity;
order.OrderLines = new List <OrderLine> {
detail
};
});
order.DateCreated = DateTime.UtcNow;
order.OrderNumber = GetOrderNumber();
order.Status = OrderStatus.Agreed;
_context.Orders.Add(order);
await _context.SaveChangesAsync();
return(await GetOrderAsync(order.Id));
}
/// <summary>
/// 获取编辑 Order
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <GetOrderForEditOutput> GetForEdit(OrderEditDto input)
{
var output = new GetOrderForEditOutput();
OrderEditDto editDto;
if (!string.IsNullOrEmpty(input.Id))
{
var entity = await _orderRepository.GetAsync(input.Id);
editDto = entity.MapTo <OrderEditDto>();
//OrderEditDto = ObjectMapper.Map<List<OrderEditDto>>(entity);
}
else
{
editDto = new OrderEditDto();
}
output.Order = editDto;
return(output);
}
/// <summary>
/// MPA版本才会用到的方法
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <GetOrderForEditOutput> GetOrderForEdit(NullableIdDto <Guid> input)
{
var output = new GetOrderForEditOutput();
OrderEditDto orderEditDto;
if (input.Id.HasValue)
{
var entity = await _orderRepository.GetAsync(input.Id.Value);
orderEditDto = entity.MapTo <OrderEditDto>();
//orderEditDto = ObjectMapper.Map<List <orderEditDto>>(entity);
}
else
{
orderEditDto = new OrderEditDto();
}
output.Order = orderEditDto;
return(output);
}
public OrderDto Edit(OrderEditDto orderEditDto)
{
return(new OrderDto(_orderUseCase.Edit(orderEditDto)));
}
public ActionResult <OrderDto> PutOrder(int id, OrderEditDto orderEditDto)
{
return(new ActionResult <OrderDto>(_orderService.Edit(orderEditDto)));
}
public async Task <OrderEditDto> PutOrderAsync(string id, OrderEditDto model)
{
await _activityLog.Post(model.Id, ActivityType.Update);
if (id != model.Id)
{
throw new InvalidOperationException("Такого замовлення не знайдено");
}
var order = await _context.Orders.AsNoTracking().Include(i => i.Counterparty)
.Include(i => i.Manager)
.Include(i => i.OrderLines)
.ThenInclude(i => i.Product)
.SingleOrDefaultAsync(s => s.Id == model.Id);
Mapper.Map(model, order);
order.ManagerId = Utilities.GetUserId(_httpContextAccessor.HttpContext.User);
if (!await CheckToModifyOrder(order))
{
throw new InvalidOperationException("Не можливо редагувати виконане замовлення, у вас немає прав для цього");
}
//remove deleted details
order.OrderLines.Where(d => model.OrderLines.All(detailDto => detailDto.Id != d.Id)).ToList()
.ForEach(deleted => _context.OrderLines.Remove(deleted));
//update or add details
model.OrderLines.ToList().ForEach(detailDto =>
{
var line = order.OrderLines.FirstOrDefault(d => d.Id == detailDto.Id);
var detail = line ?? new OrderLine();
var product = _context.Products.SingleOrDefault(w => w.Article == detailDto.ProductArticle);
detail.OrderId = order.Id;
detail.ProductId = product.Id;
detail.UnitPrice = product.Price;
detail.Quantity = detailDto.Quantity;
if (line == null)
{
order.OrderLines.Add(detail);
}
});
if (order.DeliveryDate <= DateTime.Now)
{
_logger.LogWarning(LoggingEvents.UpdateItemError, "Неможливо вибрати дану дату доставки, дата раніша можливої відправки");
order.DeliveryDate = DateTime.Now.AddDays(1); //автоматично додати один день до сьогоднішньої дати, але потрабно показати повідомлення
}
if ((int)model.Status >= (int)order.Status)
{
ChangeStatus(order);
}
else
{
_logger.LogWarning(LoggingEvents.UpdateItemError, "Неможливо змінити статус замовлення на нижчий, у вас немає прав для цього");
return(null);
}
_context.Orders.Update(order);
await _context.SaveChangesAsync();
return(Mapper.Map <OrderEditDto>(order));
}
public CreateOrEditOrderViewModel(OrderEditDto output)
{
output.MapTo(this);
}
