public async Task <ValidationResult> ValidateCancelOrderAsync(CancelOrderInput input)
{
ValidationResult validationResult = new();
if (string.IsNullOrWhiteSpace(input.Id))
{
validationResult.Messages.Add(new(nameof(CancelOrderInput.Id), "Debe seleccionar una orden de pago."));
}
else
{
Order order = await _orderRepository.GetAsync(input.Id);
if (order is null)
{
validationResult.Messages.Add(new(nameof(CancelOrderInput.Id), "La orden de pago no existe."));
}
else
{
switch (order.Status)
{
case OrderStatus.Payed:
validationResult.Messages.Add(new(nameof(CancelOrderInput.Id), "No se puede cancelar una orden que ya fue pagada."));
break;
case OrderStatus.Canceled:
validationResult.Messages.Add(new(nameof(CancelOrderInput.Id), "No se puede cancelar una orden que ya fue cancelada."));
break;
}
}
}
return(validationResult);
}
public async Task<CancelOrderOutput> CancelOrderAsync(CancelOrderInput input)
{
return new CancelOrderOutput()
{
ReturnLabelLocation = "http://returnurl/123",
};
}
public async Task <CancelOrderOutput> CancelOrderAsync(CancelOrderInput input)
{
var jobInfo = CreateStartJobInfo(GetProcessKey(nameof(CancelOrderAsync)), input);
var job = await _orchestratorClient.ExecuteJobAsync(jobInfo);
return(JsonConvert.DeserializeObject <CancelOrderOutput>(job.OutputArguments));
}
public virtual async Task <OrderDto> CancelAsync(Guid id, CancelOrderInput input)
{
var order = await GetEntityByIdAsync(id);
await AuthorizationService.CheckAsync(
order,
new OrderOperationAuthorizationRequirement(OrderOperation.Cancellation)
);
order = await _orderManager.CancelAsync(order, input.CancellationReason);
return(await MapToGetOutputDtoAsync(order));
}
public virtual async Task<OrderDto> CancelAsync(Guid id, CancelOrderInput input)
{
var order = await GetEntityByIdAsync(id);
if (order.IsPaid() || order.CustomerUserId != CurrentUser.GetId())
{
await AuthorizationService.CheckAsync(OrdersPermissions.Orders.Manage);
// Todo: Check if current user is an admin of the store.
}
order = await _orderManager.CancelAsync(order, input.CancellationReason);
return await MapToGetOutputDtoAsync(order);
}
public async Task <OperationResult <OrderDto> > CancelOrderAsync(CancelOrderInput input)
{
var validationResult = await _orderValidator.ValidateCancelOrderAsync(input);
if (validationResult.IsSuccess)
{
var order = await _orderRepository.GetAsync(input.Id);
order.Status = Domain.Shared.Enums.OrderStatus.Canceled;
await _orderRepository.UpdateAsync(order);
return(OperationResult <OrderDto> .Success(order.ConvertToDto()));
}
return(OperationResult <OrderDto> .Fail(validationResult));
}
private async Task <DialogTurnResult> PlaceOrderStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var message = stepContext.Context.Activity.AsMessageActivity().Text;
if (message.OrdinalEquals(Resource.Return) || message.OrdinalEquals(Resource.Replace))
{
await stepContext.Context.SendActivityAsync(Resource.Working_On);
var item = (Item)stepContext.Values["SelectedItem"];
var cancelInput = new CancelOrderInput()
{
OrderId = item.OrderId,
CancelReason = (string)stepContext.Values["Damage"],
};
var cancelOrderOutput = await _myRpaClient.CancelOrderAsync(cancelInput);
var orderCancelMessage = string.Format(Resource.Order_Cancelled, item.OrderId, cancelOrderOutput.ReturnLabelLocation);
await stepContext.Context.SendActivityAsync(orderCancelMessage);
if (message.OrdinalEquals(Resource.Replace))
{
var salesOrderInput = new CreateSalesOrderInput()
{
CustomerId = (string)stepContext.Values[c_customerId],
ItemId = item.ItemId,
Quantity = item.Quantity,
};
var createSaledOrderOuput = await _myRpaClient.CreateSalesOrderAsync(salesOrderInput);
var orderCreatedMessage = string.Format(Resource.Order_Created, createSaledOrderOuput.OrderId, createSaledOrderOuput.DeliveryDate.ToShortDateString());
await stepContext.Context.SendActivityAsync(orderCreatedMessage);
}
await stepContext.Context.SendActivityAsync(Resource.Anything_Else);
}
else
{
await stepContext.Context.SendActivityAsync(Resource.Cannot_Understand);
}
return(await stepContext.EndDialogAsync());
}
public async Task Order_Should_Be_Canceled()
{
// Arrange
await Order_Should_Be_Created();
Guid orderId = Guid.Empty;
UsingDbContext(db =>
{
var order = db.Orders.First();
order.OrderStatus.ShouldNotBe(OrderStatus.Canceled);
order.CanceledTime.ShouldBeNull();
orderId = order.Id;
});
var cancelRequestDto = new CancelOrderInput
{
CancellationReason = "Repeat orders."
};
// Act
var response = await _orderAppService.CancelAsync(orderId, cancelRequestDto);
// Assert
response.ShouldNotBeNull();
response.OrderStatus.ShouldBe(OrderStatus.Canceled);
response.CanceledTime.ShouldNotBeNull();
response.CancellationReason.ShouldBe("Repeat orders.");
UsingDbContext(db =>
{
var order = db.Orders.FirstOrDefault(o => o.Id == orderId);
order.ShouldNotBeNull();
order.OrderStatus.ShouldBe(OrderStatus.Canceled);
order.CancellationReason.ShouldBe("Repeat orders.");
});
}
public Task <OrderDto> CancelAsync(Guid id, CancelOrderInput input)
{
return(_service.CancelAsync(id, input));
}
/// <summary>
/// 取消运单
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <CancelOrderOutput> CancelOrder(CancelOrderInput input)
{
input.AccessToken = AccessToken;
return(await HttpPost <CancelOrderOutput>(_CancelOrderUrl, input));
}
