public async Task <ApiResult> UpdateReceive([FromBody] UpdateOrderInput input, CancellationToken cancellationToken)
{
if (Authorization == null)
{
return(new ApiResult(APIResultCode.Unknown, APIResultMessage.TokenNull));
}
var user = _tokenRepository.GetUser(Authorization);
if (user == null)
{
return(new ApiResult(APIResultCode.Unknown, APIResultMessage.TokenError));
}
var data = await _orderRepository.GetIncludeAsync(input.Id, cancellationToken);
if (data.OrderStatusValue != OrderStatus.WaitingTake.Value)
{
throw new NotImplementedException("不是有效状态值！");
}
await _orderRepository.UpdateAsync(new OrderDto
{
Id = input.Id,
OrderStatusValue = OrderStatus.WaitingReceive.Value,
OrderStatusName = OrderStatus.WaitingReceive.Name,
OperationTime = DateTimeOffset.Now,
OperationUserId = user.Id.ToString(),
});
return(new ApiResult());
}
public async Task <ApiResult> UpdateAccept([FromBody] UpdateOrderInput input, CancellationToken cancellationToken)
{
if (Authorization == null)
{
return(new ApiResult(APIResultCode.Unknown, APIResultMessage.TokenNull));
}
var user = _tokenRepository.GetUser(Authorization);
if (user == null)
{
return(new ApiResult(APIResultCode.Unknown, APIResultMessage.TokenError));
}
var data = await _orderRepository.GetIncludeAsync(input.Id, cancellationToken);
if (data.OrderStatusValue != OrderStatus.WaitingAccept.Value)
{
throw new NotImplementedException("不是有效状态值！");
}
await _orderRepository.UpdateAsync(new OrderDto
{
Id = input.Id,
OrderStatusValue = OrderStatus.WaitingSend.Value,
OrderStatusName = OrderStatus.WaitingSend.Name,
OperationTime = DateTimeOffset.Now,
OperationUserId = user.Id.ToString(),
});
var propertyUserList = await _userRepository.GetAllPropertyAsync(new UserDto { SmallDistrictId = data.Industry.BuildingUnit.Building.SmallDistrictId.ToString() }, cancellationToken);
foreach (var item in propertyUserList)
{
var smallDistrict = await _smallDistrictRepository.GetAsync(item.SmallDistrictId, cancellationToken);
SignalR("1", smallDistrict.PropertyCompanyId.ToString(), item.Id.ToString(), data);
}
await OrderPushRemind(new OrderPushModel
{
Type = "已接单",
CreateTime = data.CreateOperationTime.Value,
Id = data.Id.ToString(),
Number = data.Number,
PaymentPrice = data.PaymentPrice,
ReceiverName = data.ReceiverName
}, data.CreateOperationUserId.ToString());
return(new ApiResult());
}
public async Task <ApiResult> UpdateSend([FromBody] UpdateOrderInput input, CancellationToken cancellationToken)
{
if (Authorization == null)
{
return(new ApiResult(APIResultCode.Unknown, APIResultMessage.TokenNull));
}
var user = _tokenRepository.GetUser(Authorization);
if (user == null)
{
return(new ApiResult(APIResultCode.Unknown, APIResultMessage.TokenError));
}
var data = await _orderRepository.GetIncludeAsync(input.Id, cancellationToken);
if (data.OrderStatusValue != OrderStatus.WaitingSend.Value)
{
throw new NotImplementedException("不是有效状态值！");
}
await _orderRepository.UpdateAsync(new OrderDto
{
Id = input.Id,
OrderStatusValue = OrderStatus.WaitingTake.Value,
OrderStatusName = OrderStatus.WaitingTake.Name,
OperationTime = DateTimeOffset.Now,
OperationUserId = user.Id.ToString()
});
var shopUserList = await _userRepository.GetByShopIdAsync(data.ShopId.ToString(), cancellationToken);
foreach (var item in shopUserList)
{
SignalR("2", data.ShopId.ToString(), item.Id.ToString(), data);
}
//await OrderPushRemind(new OrderPushModel
//{
// Type = "已配送",
// CreateTime = data.CreateOperationTime.Value,
// Id = data.Id.ToString(),
// Number = data.Number,
// PaymentPrice = data.PaymentPrice,
// ReceiverName = data.ReceiverName
//}, data.OwnerCertificationRecordId.ToString());
return(new ApiResult());
}
public async Task <Order> UpdateOrder(int id, UpdateOrderInput updateOrderInput)
{
try
{
Order _order = await _ordersService.UpdateOrder(id, updateOrderInput);
return(_order);
}
catch (Exception ex)
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage(ex.Message)
.SetCode("UPDATE_ERROR")
.Build());
}
}
public OrderDto Update(UpdateOrderInput input)
{
var existingOrderItem = orderItemRepository.GetAll().AsNoTracking().Include(i => i.Order).FirstOrDefault(f => f.Id == input.Id);
var mappedInput = mapper.Map <OrderItemDto>(input);
//Validate the orderItem
if (input == null)
{
throw new OrderItemNotFoundException();
}
else if (input.Quantity == existingOrderItem.Quantity)
{
throw new SameQuantityUpdateException();
}
using (var unitOfWork = unitOfWorkManager.Begin())
{
try
{
//Update qty in stock
var orderItems = new List <OrderItemDto> {
mappedInput
};
productAppService.UpdateProductQuantityInStock(orderItems);
//update order
var subTotal = existingOrderItem.UnitPrice * input.Quantity;
existingOrderItem.Order.SetOrderTotal(existingOrderItem.Order.OrderTotal, existingOrderItem.SubTotal, subTotal);
existingOrderItem.SetSubTotal(subTotal);
existingOrderItem.SetQuantity(input.Quantity);
orderItemRepository.Update(existingOrderItem);
orderRepository.Update(existingOrderItem.Order);
unitOfWork.Complete();
return(mapper.Map <OrderDto>(existingOrderItem.Order));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
}
public async Task <OrderDto> UpdateOrder(UpdateOrderInput input)
{
Order order = _repository.GetAll().Include(x => x.Invoices).ThenInclude(x => x.InvocePaymentProviders).Single(x => x.Id == input.Id);
if (order.Status.Status == OrderStatus.OrderStatusValue.Payed)
{
throw new UserFriendlyException("No se puede editar una orden que ya fue Pagada.");
}
if (order.Status.Status == OrderStatus.OrderStatusValue.Canceled)
{
throw new UserFriendlyException("No se puede editar una orden que ya fue Camcelada.");
}
order = _mapper.Map <UpdateOrderInput, Order>(input, order);
_repository.Update(order);
var invocePaymentProvider = order.Invoices.Single().InvocePaymentProviders.Single();
if (order.Status.Status == OrderStatus.OrderStatusValue.Payed)
{
switch (order.Type.Type)
{
case OrderType.OrderTypeValue.Subscription:
_eventBus.Trigger(new OrderSubscriptionPayedEventData(order));
break;
case OrderType.OrderTypeValue.RenewSubscription:
_eventBus.Trigger(new OrderRenewSubscriptionPayedEventData(order));
break;
case OrderType.OrderTypeValue.Extra:
_eventBus.Trigger(new OrderExtraPayedEventData(order));
break;
default:
throw new NotImplementedException();
}
switch (order.Currency.Code)
{
case Domain.ValueObjects.Currency.CurrencyValue.ARS:
await _mobbexService.CancelInvoice(invocePaymentProvider);
break;
case Domain.ValueObjects.Currency.CurrencyValue.USD:
await _paypalService.CancelInvoice(invocePaymentProvider);
break;
default:
throw new NotImplementedException();
}
}
if (order.Status.Status == OrderStatus.OrderStatusValue.PaymentPending)
{
switch (order.Currency.Code)
{
case Domain.ValueObjects.Currency.CurrencyValue.ARS:
await _mobbexService.CancelInvoice(invocePaymentProvider);
var newinvoicePaymentProvider = await _mobbexService.CreateUriForPayment(order.Invoices.Single(), order, string.Empty);
invocePaymentProvider.Link = newinvoicePaymentProvider.Link;
invocePaymentProvider.Transaction = newinvoicePaymentProvider.Transaction;
break;
case Domain.ValueObjects.Currency.CurrencyValue.USD:
invocePaymentProvider = await _paypalService.UpdateAmountInvoice(invocePaymentProvider, order);
break;
default:
throw new NotImplementedException();
}
_invoicePaymentProviderRepository.Update(invocePaymentProvider);
}
return(_mapper.Map <OrderDto>(order));
}
//Update order record
public async Task <Order> UpdateOrder(int id, UpdateOrderInput updateOrderInput)
{
Debug.WriteLine(JsonConvert.SerializeObject(updateOrderInput.OrderDetails));
//CultureInfo en = new CultureInfo("en");
//search for order record
Order order = await db.Orders
.Include(p => p.OrderDetails)
.SingleAsync(p => p.OrderID == id);
if (order == null)
{
throw new Exception("Order not found");
}
//search for a customer record
Customer customer = await db.Customers.FindAsync(updateOrderInput.CustomerID);
if (customer == null)
{
throw new Exception("Customer not found");
}
order.Customer = customer;
order.DeliveryAddress = updateOrderInput.DeliveryAddress;
order.DeliveryDate = DateTime.Parse(updateOrderInput.DeliveryDate);
order.Currency = "R";
order.OrderStatus = updateOrderInput.OrderStatus;
List <OrderDetail> _orderDetails = new List <OrderDetail>(order.OrderDetails.ToList());
foreach (var item in _orderDetails)
{
order.OrderDetails.Remove(item);
}
//order.OrderDetails.Clear();
order.SubTotal = 0;
order.Tax = 0;
order.Total = 0;
await db.SaveChangesAsync();
Debug.WriteLine(JsonConvert.SerializeObject(order));
//update orderDetails
order.OrderDetails = new List <OrderDetail>();
foreach (var item in updateOrderInput.OrderDetails)
{
var orderDetail = new OrderDetail();
orderDetail.ProductID = item.ProductID;
orderDetail.ProductName = item.ProductName;
orderDetail.UnitPrice = item.UnitPrice;
orderDetail.Currency = item.Currency;
orderDetail.Quantity = item.Quantity;
orderDetail.UnitOfMeasure = item.UnitOfMeasure;
order.SubTotal += item.UnitPrice * item.Quantity;
order.OrderDetails.Add(orderDetail);
}
order.Tax = order.SubTotal * (decimal)0.15;
order.Total = order.SubTotal + order.Tax;
//db.Orders.Update(order);
Debug.WriteLine(JsonConvert.SerializeObject(order));
await db.SaveChangesAsync();
return(order);
}
