public async Task <ActionResult> DeleteCompany(long id)
{
var command = new DeleteCompanyCommand(id);
var result = await this.mediator.Send(command);
return(Ok(result));
}
public async Task <IActionResult> Delete(Guid id)
{
var cmd = new DeleteCompanyCommand(id);
var result = await _mediator.Send(cmd);
return(Ok(result));
}
public async Task <DeleteCompanyByIdResponse> Handle(DeleteCompanyByIdRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticatorRole == AppRole.Employee)
{
return(new DeleteCompanyByIdResponse()
{
Error = new ErrorModel(ErrorType.Unauthorized)
});
}
var query = new GetCompanyQuery()
{
Id = request.CompanyId
};
var company = await queryExecutor.Execute(query);
if (company == null)
{
return(new DeleteCompanyByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var command = new DeleteCompanyCommand()
{
Parameter = company
};
var deletedCompany = await commandExecutor.Execute(command);
return(new DeleteCompanyByIdResponse
{
Data = deletedCompany
});
}
public async Task <Result> Delete([FromBody] DeleteCompanyCommand cmd)
{
_logger.LogInformation($"接收到请求{HttpContext.Request.Host}{HttpContext.Request.Path},参数 {JsonConvert.SerializeObject(cmd)}");
var result = await _mediator.Send(cmd, HttpContext.RequestAborted);
return(result);
}
public DeleteCompanyService(DeleteCompanyCommand companyCommand, ICompanyRepository companyRepository)
: base(companyCommand)
{
_companyCommand = companyCommand;
_companyRepository = companyRepository;
Run();
}
public Command DeleteCompany(int id)
{
var companyCommand = new DeleteCompanyCommand(id);
new DeleteCompanyService(companyCommand, _companyRepository);
return(companyCommand);
}
/// <summary>
/// Handle delete command.
/// </summary>
public void HandleDelete(DeleteCompanyCommand command, IAppUnitOfWorkFactory uowFactory)
{
using (IAppUnitOfWork uow = uowFactory.Create())
{
Company company = uow.CompanyRepository.Get(command.CompanyId);
uow.CompanyRepository.Remove(company);
uow.SaveChanges();
}
}
public async Task <APIResult> Delete([FromBody] DeleteCompanyCommand command)
{
var rs = await mediator.Send(command);
return(new APIResult()
{
Result = rs
});
}
public async Task <IActionResult> DeleteCompany(string company)
{
var command = new DeleteCompanyCommand
{
CompanyId = company
};
await _mediator.Send(command);
return(NoContent());
}
/// <summary>
/// Método para remover uma Company
/// </summary>
/// <param name="command">Comando de remoção da Company</param>
/// <returns>Retorna a Company removida</returns>
public Company Delete(DeleteCompanyCommand command)
{
var company = _repository.GetById(command.CompanyId);
_repository.Delete(company);
if (Commit())
{
return(company);
}
return(null);
}
public Task <HttpResponseMessage> Delete(int id)
{
//var company = _service.Delete(id);
var command = new DeleteCompanyCommand(
idCompany: id,
statusCompany: EStatusCompany.Inativa
);
var company = _service.Delete(command);
return(CreateResponse(HttpStatusCode.OK, company));
}
public void CreateInstance_WhenInvokedWithValidParameters()
{
//Arrange
var sportscardFactoryMock = new Mock <ISportscardFactory>();
var companyService = new Mock <ICompanyService>();
//Act
var deleteCompanyCommand = new DeleteCompanyCommand(sportscardFactoryMock.Object, companyService.Object);
//Assert
Assert.IsNotNull(deleteCompanyCommand);
Assert.IsInstanceOfType(deleteCompanyCommand, typeof(ICommand));
}
public async Task <CoreResult> Delete(long Id)
{
CoreResult result = new CoreResult();
DeleteCompanyCommand command = new DeleteCompanyCommand(Id);
var res = await _bus.SendCommandAsync(command);
if (res)
{
result.Success("删除成功");
}
else
{
result.Failed("删除成功");
}
return(result);
}
public async Task Handle_ValidCompany_ReturnsSpecyficType()
{
//Arrange
var handler = new DeleteCompanyCommandHandler(_mockCompanyRepository.Object, _logger.Object, _mockCurrentUserService.Object);
var command = new DeleteCompanyCommand()
{
Id = "1"
};
//Act
var result = await handler.Handle(command, CancellationToken.None);
//Assert
result.ShouldBeOfType <Unit>();
}
public void Handle_InvalidCompanyId_ThrowsNotFoundException()
{
//Arrange
var handler = new DeleteCompanyCommandHandler(_mockCompanyRepository.Object, _logger.Object, _mockCurrentUserService.Object);
var command = new DeleteCompanyCommand()
{
Id = "99"
};
//Act
Func <Task> func = () => handler.Handle(command, CancellationToken.None);
//Assert
func.ShouldThrowAsync <NotFoundException>();
}
public void ThrowArgumentException_WhenInvokedWithEmptyParametersCollection()
{
// Arrange
var sportscardFactoryMock = new Mock <ISportscardFactory>();
var companyServiceMock = new Mock <ICompanyService>();
var companyName = "Progress";
var expectedMessage = $"Company \"{companyName}\" was deleted from database.";
var deleteCompanyCommand = new DeleteCompanyCommand(sportscardFactoryMock.Object, companyServiceMock.Object);
var parameters = new List <string>();
//Act && Assert
Assert.ThrowsException <ArgumentException>(() => deleteCompanyCommand.Execute(parameters));
}
public void Handle_NotOwnerUser_ThrowsForbiddenAccessException()
{
//Arrange
_mockCurrentUserService.SetupGet(x => x.UserId).Returns("user2");
var handler = new DeleteCompanyCommandHandler(_mockCompanyRepository.Object, _logger.Object, _mockCurrentUserService.Object);
var command = new DeleteCompanyCommand()
{
Id = "1"
};
//Act
Func <Task> func = () => handler.Handle(command, CancellationToken.None);
//Assert
func.ShouldThrowAsync <ForbiddenAccessException>();
}
public async Task <IActionResult> DeleteCompanyAsync(int companyId)
{
if (companyId < 1)
{
return(Error("Invalid Company Id"));
}
var userId = GetUserIdFromClaim();
_logger.LogInformation($"Deleting Company: ${companyId}, Requested By:${userId}");
var command = new DeleteCompanyCommand
{
Id = companyId,
UserId = userId
};
var result = await _messages.Dispatch(command).ConfigureAwait(false);
return(Ok(result));
}
public void CallCompanyDeleteMethodOnce_WhenInvokedWithValidParameters()
{
// Arrange
var sportscardFactoryMock = new Mock <ISportscardFactory>();
var companyServiceMock = new Mock <ICompanyService>();
var companyName = "Progress";
var deleteCompanyCommand = new DeleteCompanyCommand(sportscardFactoryMock.Object, companyServiceMock.Object);
var parameters = new List <string>()
{
companyName
};
//Act
deleteCompanyCommand.Execute(parameters);
//Assert
companyServiceMock.Verify(x => x.DeleteCompany(companyName), Times.Once);
}
public async Task Handle_ValidCompany_DeletedFromCompanyRepository()
{
//Arrange
var handler = new DeleteCompanyCommandHandler(_mockCompanyRepository.Object, _logger.Object, _mockCurrentUserService.Object);
var allCompaniesBeforeCount = (await _mockCompanyRepository.Object.GetAllAsync()).Count;
var command = new DeleteCompanyCommand()
{
Id = "1"
};
//Act
await handler.Handle(command, CancellationToken.None);
var allCompaniesAfterCount = await _mockCompanyRepository.Object.GetAllAsync();
//Assert
allCompaniesAfterCount.Count.ShouldBe(allCompaniesBeforeCount - 1);
}
public void ReturnSuccessMessage_WhenInvokedWithValidParameters()
{
// Arrange
var sportscardFactoryMock = new Mock <ISportscardFactory>();
var companyServiceMock = new Mock <ICompanyService>();
var companyName = "Progress";
var expectedMessage = $"Company \"{companyName}\" was deleted from database.";
var deleteCompanyCommand = new DeleteCompanyCommand(sportscardFactoryMock.Object, companyServiceMock.Object);
var parameters = new List <string>()
{
companyName
};
//Act
var actualMessage = deleteCompanyCommand.Execute(parameters);
//Assert
Assert.AreEqual(expectedMessage, actualMessage);
}
public async Task <DeleteCompanyByIdResponse> Handle(DeleteCompanyByIdRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticationCompanyId != request.Id)
{
return(new DeleteCompanyByIdResponse()
{
Error = new ErrorModel(ErrorType.Forbidden)
});
}
var query = new GetCompanyQuery()
{
Id = request.Id
};
var companiesFromDb = await this.queryExecutor.Execute(query);
if (companiesFromDb == null)
{
return(new DeleteCompanyByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var mappedCommand = this.mapper.Map <Company>(request);
var command = new DeleteCompanyCommand()
{
Parameter = mappedCommand
};
var deletedCompany = await this.commandExecutor.Execute(command);
var response = new DeleteCompanyByIdResponse()
{
Data = deletedCompany
};
return(response);
}
public async Task Delete(Guid id)
{
var commandDelete = new DeleteCompanyCommand(id);
await appService.Delete(commandDelete);
}
public async Task Delete(DeleteCompanyCommand commandDelete)
{
//send command to broker
await producer.Send <DeleteCompanyCommand, Company>(commandDelete);
}
public void Delete(DeleteCompanyCommand command)
{
AppliedEvents.Add(new CompanyDeletedEvent(this, command.MessageId));
}
public void DeleteCompany(DeleteCompanyCommand command)
{
this.StatusCompany = command.StatusCompany;
}
