public async Task Handle(RemoveOrderCommand message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
var record = await _orderRepository.Get(message.OrderId);
if (record == null)
{
return;
}
if (record.Status == OrderAggregateStatus.Confirmed)
{
await UpdateDiscount(record, true);
await UpdateProductStock(record, true);
}
await _orderRepository.Remove(record);
_eventPublisher.Publish(new OrderRemovedEvent
{
Id = message.OrderId,
CommonId = message.CommonId,
Subject = message.Subject
});
}
public async Task <RemoveOrderValidationResult> Validate(RemoveOrderCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var order = await _orderRepository.Get(command.OrderId);
if (order == null)
{
return(new RemoveOrderValidationResult(ErrorDescriptions.TheOrderDoesntExist));
}
if (order.Subject != command.Subject)
{
return(new RemoveOrderValidationResult(ErrorDescriptions.TheOrderCannotBeRemovedByYou));
}
if (order.IsLabelPurchased)
{
return(new RemoveOrderValidationResult(ErrorDescriptions.ThePurchasedRequestLabelCannotBeRemoved));
}
if (order.Status == OrderAggregateStatus.Received)
{
return(new RemoveOrderValidationResult(ErrorDescriptions.TheReceivedOrderCannotBeRemoved));
}
return(new RemoveOrderValidationResult());
}
private void btnDeleteOrder_Click(object sender, System.EventArgs e)
{
var order = (IOrder)lstOrdersDetail.SelectedItem;
if (order != null)
{
var addCmd = Empire.Current.Commands.OfType <AddOrderCommand>().SingleOrDefault(c => c.Order == order);
if (addCmd == null)
{
// not a newly added order, so create a remove command to take it off the server
var remCmd = new RemoveOrderCommand(Fleet, order);
Empire.Current.Commands.Add(remCmd);
remCmd.Execute(); // show change locally
}
else
{
// a newly added order, so just get rid of the add command
Empire.Current.Commands.Remove(addCmd);
addCmd.Execute(); // show change locally
}
Bind();
if (OrdersChanged != null)
{
OrdersChanged();
}
}
}
private bool AuthorizeRemoveOrder(RemoveOrderCommand context)
{
var IsAdmin = context.Roles.Where(role => role == "admin").Any();
var OrderBelongToUser = orderRepo.FindByExpression(o => o.Id == context.OrderId && o.UserId == context.Userid).Any();
// user not bought product , it just added
var orderIsInAddedStage = orderRepo.FindByExpression(o => o.Id == context.OrderId && o.status == OrderStatusEnum.ADDED).Any();
return((OrderBelongToUser && orderIsInAddedStage) || (IsAdmin && orderIsInAddedStage));
}
public async void RemoveOrderHandlerFailure()
{
var mockOrder = new MockOrderData();
var createOrder = mockOrder.CreateOrder();
RemoveOrderCommand removeOrderCommand = new RemoveOrderCommand(createOrder.OrderId);
RemoveOrderHandler removeOrderHandler = new RemoveOrderHandler();
var actual = await removeOrderHandler.Handle(removeOrderCommand, new CancellationToken());
var actualbool = actual.Error;
var expectedbool = true;
Assert.NotEqual(expectedbool, actualbool);
}
public async Task <Response <bool> > Handle(RemoveOrderCommand request, CancellationToken cancellationToken)
{
if (AuthorizeRemoveOrder(request))
{
Order order = await orderRepo.GetOrderAsync(request.OrderId);
await orderRepo.Remove(order);
return(Response.Ok());
}
return(Response.Fail <bool>("شما مجاز به انجام این کار نیسصتید", StatusCodeEnum.NOTAUTHORIZE));
}
public async Task <IActionResult> Delete(string id)
{
if (!Guid.TryParse(id, out Guid orderId))
{
return(NotFound());
}
var command = new RemoveOrderCommand();
command.SetId(orderId);
var order = await Mediator.Send(command);
return(Ok(order.Identity));
}
public async Task <Unit> Handle(RemoveOrderCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(await Unit.Task);
}
_orderRepository.Remove(message.Id);
if (Commit())
{
await Bus.RaiseEvent(new OrderRemovedEvent(message.Id));
}
return(await Unit.Task);
}
public Task <bool> Handle(RemoveOrderCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
_orderRepository.Remove(message.Id);
if (Commit())
{
_bus.RaiseEvent(new OrderRemovedEvent(message.Id));
}
return(Task.FromResult(true));
}
public async Task <IActionResult> Execute(RemoveOrderCommand removeOrderCommand)
{
if (removeOrderCommand == null)
{
throw new ArgumentNullException(nameof(removeOrderCommand));
}
var validationResult = await _removeOrderValidator.Validate(removeOrderCommand);
if (!validationResult.IsValid)
{
var error = _responseBuilder.GetError(ErrorCodes.Server, validationResult.Message);
return(_controllerHelper.BuildResponse(System.Net.HttpStatusCode.BadRequest, error));
}
_commandSender.Send(removeOrderCommand);
return(new OkResult());
}
public void Remove(Guid id)
{
var removeCommand = new RemoveOrderCommand(id);
_bus.SendCommand(removeCommand);
}
private void RemoveOrder(IConstructionOrder order, bool rebindGui = true)
{
var cmds = Empire.Current.Commands.OfType <AddOrderCommand>().Where(o => o.Order == order).ToArray();
if (cmds.Any())
{
// remove add-order command since the order is new this turn
foreach (var cmd in cmds)
{
removedCommands.Add(cmd);
}
}
else
{
cmds = newCommands.OfType <AddOrderCommand>().Where(o => o.Order == order).ToArray();
if (cmds.Any())
{
// Not only new this turn, but new this instance of this form!
foreach (var cmd in cmds)
{
newCommands.Remove(cmd);
}
}
else
{
// add remove-order command
var cmd = new RemoveOrderCommand(ConstructionQueue, order);
newCommands.Add(cmd);
}
}
// remove the order
ConstructionQueue.Orders.Remove(order);
if (order.Template is IDesign)
{
var design = order.Template as IDesign;
// is this a new design we've never built before and are not building any more of? then don't tell the server so other players don't know ;)
if (design.IsNew && !BuildingAnywhere(design))
{
// HACK - why can there be multiple commands to create the same design?
foreach (var cmd in Empire.Current.Commands.OfType <ICreateDesignCommand>().Where(c => c.Design == design).ToArray())
{
Empire.Current.Commands.Remove(cmd);
}
}
}
if (rebindGui)
{
BindQueueListView();
if (chkOnlyLatest.Checked)
{
BindUpgradeListView(Empire.Current.UnlockedItems.OfType <FacilityTemplate>().Where(f => f.Cost.Any()).OnlyLatestVersions(f => f.Family));
}
else
{
BindUpgradeListView(Empire.Current.UnlockedItems.OfType <FacilityTemplate>().Where(f => f.Cost.Any()));
}
}
}
