public UpdateCompanyService(UpdateCompanyCommand companyCommand, ICompanyRepository companyRepository)
: base(companyCommand)
{
_companyCommand = companyCommand;
_companyRepository = companyRepository;
Run();
}
public async Task <CompanyViewModel> Update(CompanyViewModel viewModel)
{
// Arrange
viewModel.Name = $"{viewModel.Name}-{DateTime.UtcNow.ToLongTimeString()}";
var command = new UpdateCompanyCommand(viewModel.Id, viewModel.Name);
var requestBody =
new StringContent(JsonConvert.SerializeObject(command), Encoding.UTF8, "application/json");
// Act
var response = await client.PutAsync($"{url}/{viewModel.Id}", requestBody);
var apiResponse = JsonConvert.DeserializeObject <ApiResponse>(await response.Content.ReadAsStringAsync());
var viewModelResponse =
JsonConvert.DeserializeObject <CompanyViewModel>(apiResponse.Result.ToString());
// Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
apiResponse.StatusCode.Should().Be((int)HttpStatusCode.OK);
viewModelResponse.Should().BeOfType <CompanyViewModel>();
viewModelResponse.Id.Should().NotBeEmpty();
viewModelResponse.Id.Should().Be(viewModel.Id);
viewModelResponse.Name.Should().Be(viewModel.Name);
return(viewModelResponse);
}
/// <summary>
/// Gets the ids.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="customerId">The customer identifier.</param>
/// <param name="info">The information.</param>
/// <param name="companyId">The company identifier.</param>
/// <returns></returns>
private bool GetIds(UpdateCompanyCommand command, InfoAccumulator info, out int customerId, out int companyId)
{
DateTime date;
try {
customerId = CustomerIdEncryptor.DecryptCustomerId(command.CustomerId, command.RequestOrigin, out date);
} catch (Exception ex) {
Log.Error(ex.Message);
info.AddError("Invalid customer id.");
customerId = -1;
companyId = -1;
return(false);
}
try {
companyId = CompanyIdEncryptor.DecryptCompanyId(command.CustomerId, command.RequestOrigin, out date);
} catch (Exception ex) {
Log.Error(ex.Message);
info.AddError("Invalid company id.");
customerId = -1;
companyId = -1;
return(false);
}
return(true);
}
public void ShouldFailOnUpdateCompany()
{
//Register a new company
RegisterCompanyCommand registerCommand = new RegisterCompanyCommand
{
Name = "Microsoft Corporation",
Description = "Microsoft corporation",
Cnpj = "59009518000141",
InscricaoEstadual = "115153",
Email = "*****@*****.**",
OwnerName = "Satya Nadella",
OwnerBirthday = DateTime.Now.AddYears(-30),
OwnerCpf = "23854410099"
};
service.Register(registerCommand);
//Change existing seed company to same CNPJ from new company
UpdateCompanyCommand command = new UpdateCompanyCommand
{
CompanyId = new Guid("354f3d5b-52e9-4e71-917f-c1a6d977c5a1"),
Name = "Microsoft Corporation",
Description = "Microsoft corporation",
Cnpj = "49009518000141",
InscricaoEstadual = "115153",
Email = "*****@*****.**",
OwnerName = "Satya Nadella",
OwnerBirthday = DateTime.Now.AddYears(-30),
OwnerCpf = "23854410099"
};
service.Update(command);
Assert.AreEqual("CNPJ duplicado", domainNotificationHandler.GetNotifications().First().Title);
}
public async Task <IActionResult> UpdateCompany(long id, UpdateCompanyCommand command)
{
command.Id = id;
await _companiesService.UpdateCompany(command);
return(Ok());
}
public async Task <IActionResult> Put(Guid id, [FromBody] CompanyDTO value)
{
var cmd = new UpdateCompanyCommand(id, value);
var result = await _mediator.Send(cmd);
return(Ok(result));
}
public async Task <CompanyViewModel> Update(UpdateCompanyCommand command)
{
//send command to broker
var result = await producer.Send <UpdateCompanyCommand, Company>(command);
return(mapper.Map <CompanyViewModel>(result));
}
public async Task <CompanyViewModel> Update(UpdateCompanyCommand command)
{
var response = await controller.Update(command.Id, command) as OkObjectResult;
var viewmodel = response.Value as CompanyViewModel;
return(viewmodel);
}
public IActionResult Update(Guid id, [FromBody] UpdateCompanyCommand command)
{
command.CompanyId = id;
_companyApplicationService.Update(command);
return(CreateResponse());
}
public async Task <IActionResult> Put(int id, UpdateCompanyCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
return(Ok(await _mediator.Send(command)));
}
public async Task <IActionResult> Update([FromRoute] Guid id, [FromBody] UpdateCompanyCommand command)
{
if (!command.Id.Equals(id))
{
return(BadRequest("Invalid Id passed from route"));
}
return(Ok(await appService.Update(command)));
}
public async Task <APIResult> Update([FromBody] UpdateCompanyCommand command)
{
var rs = await mediator.Send(command);
return(new APIResult()
{
Result = rs
});
}
/// <summary>
/// Validates the command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="info">The information.</param>
/// <returns></returns>
private bool ValidateCommand(UpdateCompanyCommand command, InfoAccumulator info)
{
if (StringUtils.IsEmpty(command.CustomerId))
{
info.AddError("invalid customer id");
return(false);
}
return(true);
}
public async Task <ActionResult> Update([FromRoute] string id, [FromBody] UpdateCompanyCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
await Mediator.Send(command);
return(Ok());
}
public async Task <ActionResult> UpdatePost(int id, [FromForm] UpdateCompanyCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
await Mediator.Send(command);
return(RedirectToAction("Index", id));
}
public async Task <IActionResult> Update([FromRoute] Guid id, [FromBody] UpdateCompanyCommand command)
{
var result = await appService.Get(id);
if (result == null)
{
return(NotFound());
}
return(Ok(await appService.Update(command)));
}
/// <summary>
/// Handle update command.
/// </summary>
public void HandleUpdate(UpdateCompanyCommand command, IAppUnitOfWorkFactory uowFactory)
{
using (IAppUnitOfWork uow = uowFactory.Create())
{
if (uow.Companies.Any(c => c.Name == command.Name.Trim() && c.Id != command.CompanyId))
{
throw new DomainException("The company with the same name already exists.");
}
Company company = uow.CompanyRepository.Get(command.CompanyId);
company.Name = command.Name;
uow.SaveChanges();
}
}
public async Task <IActionResult> UpdateCompanyAsync(CompanyDataDto dto)
{
var claimsIdentity = this.User.Identity as ClaimsIdentity;
var userId = claimsIdentity.Claims.ToList().FirstOrDefault(x => x.Type == "id").Value;
var command = new UpdateCompanyCommand
{
Dto = dto,
UserId = userId
};
return(await _mediator.Send(command));
}
public ActionResult Edit(UpdateCompanyCommand command)
{
try
{
pipelineService.HandleCommand(command);
}
catch (DomainException ex)
{
ModelState.AddModelError(string.Empty, ex);
return(View(command));
}
return(RedirectToAction("Index"));
}
/// <summary>
/// Creates the experian address.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="customerId">The customer identifier.</param>
/// <returns></returns>
private CustomerAddress CreateExperianAddress(UpdateCompanyCommand command, int customerId)
{
return(new CustomerAddress {
addressType = CustomerAddressType.ExperianCompanyAddress,
CustomerId = customerId,
Organisation = command.ExperianCompanyInfo.BusName,
Line1 = command.ExperianCompanyInfo.AddrLine1,
Line2 = command.ExperianCompanyInfo.AddrLine2,
Line3 = command.ExperianCompanyInfo.AddrLine3,
Town = command.ExperianCompanyInfo.AddrLine4,
Postcode = command.ExperianCompanyInfo.PostCode
});
}
public void Should_Have_Error_When_Name_Is_Already_Exists()
{
//Arrange
var command = new UpdateCompanyCommand()
{
Name = "CompanyName1"
};
//Act
var result = _validator.TestValidate(command);
//Assert
result.ShouldHaveValidationErrorFor(x => x.Name);
}
public void Should_Have_Error_When_Name_Is_Greater_Than_30_Characters()
{
//Arrange
var command = new UpdateCompanyCommand()
{
Name = new string('T', 31)
};
//Act
var result = _validator.TestValidate(command);
//Assert
result.ShouldHaveValidationErrorFor(x => x.Name);
}
public void Should_Have_Error_When_Name_Is_Invalid_Format()
{
//Arrange
var command = new UpdateCompanyCommand()
{
Name = "Test/"
};
//Act
var result = _validator.TestValidate(command);
//Assert
result.ShouldHaveValidationErrorFor(x => x.Name);
}
public async Task UpdateCompany(UpdateCompanyCommand command)
{
var company = _context.Companies.Find(command.Id);
if (company is null)
{
throw new Exception("Company does not exist");
}
company.Name = command.Name;
company.EstablishmentYear = command.EstablishmentYear;
await _context.SaveChangesAsync();
}
public Company Update(UpdateCompanyCommand command)
{
var company = _repository.GetById(command.IdCompany);
company.UpdateCompany(command, company.StatusCompany);
_repository.Update(company);
if (Commit())
{
return(company);
}
return(null);
}
public async Task <CompanyViewModel> Update(UpdateCompanyCommand command)
{
//arrange
const int expectedNumberOfErrors = 0;
//act
var response = await appService.Update(command);
//assert
command.ValidateModelAnnotations().Count.Should().Be(expectedNumberOfErrors);
response.Id.Should().Be(command.Id);
response.Name.Should().Be(command.Name);
return(response);
}
public void Handle_InvalidCompanyId_ThrowsNotFoundException()
{
//Arrange
var handler = new UpdateCompanyCommandHandler(_mockCompanyRepository.Object, _mapper, _logger.Object, _mockCurrentUserService.Object);
var command = new UpdateCompanyCommand()
{
Id = "99"
};
//Act
Func <Task> func = () => handler.Handle(command, CancellationToken.None);
//Assert
func.ShouldThrowAsync <NotFoundException>();
}
public async Task <CoreResult> Update([FromBody] UpdateCompanyRequestDto dto)
{
CoreResult result = new CoreResult();
UpdateCompanyCommand command = new UpdateCompanyCommand(dto);
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 UpdateCompanyCommandHandler(_mockCompanyRepository.Object, _mapper, _logger.Object, _mockCurrentUserService.Object);
var command = new UpdateCompanyCommand()
{
Id = "1", Name = "UpdateCompany"
};
//Act
var result = await handler.Handle(command, CancellationToken.None);
//Assert
result.ShouldBeOfType <Unit>();
}
public void UpdateCompany(UpdateCompanyCommand command, EStatusCompany status)
{
if (!this.UpdateCompanyScopeIsValid(command, status))
{
return;
}
this.CompanyName = command.CompanyName;
this.ClassificationCompany = command.ClassificationCompany;
this.Cnpj = command.Cnpj;
this.Email = command.Email;
this.StateInscription = command.StateInscription;
this.StatusCompany = command.StatusCompany;
this.FantasyName = command.FantasyName;
this.SizeCompany = command.SizeCompany;
}
