public async Task Should_Update_Basic_Company_Information_When_Update_Company()
{
// given
await client.DeleteAsync("Company/clear");
Company company = new Company(name: "Apple");
string request = JsonConvert.SerializeObject(company);
StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");
await client.PostAsync("Company/companies", requestBody);
// when
UpdateCompany updateCompany = new UpdateCompany("Pineapple");
string putRequest = JsonConvert.SerializeObject(updateCompany);
StringContent putRequestBody = new StringContent(putRequest, Encoding.UTF8, "application/json");
var response = await client.PutAsync($"Company/companies/{company.Id}", putRequestBody);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
Company actualCompany = JsonConvert.DeserializeObject <Company>(responseString);
// then
Assert.Equal(new Company("Pineapple")
{
Id = company.Id
}, actualCompany);
}
public void CanValidateCountryId()
{
//Arrange
IValidator <UpdateCompany> validator = GetValidator();
UpdateCompany updateCompany = new UpdateCompany
{
Id = serviceMockFactory.CompanyMock.ValidId,
Name = "Test Name",
CountryId = serviceMockFactory.CountryMock.ValidId
};
//Act
ValidationResult result = validator.Validate(updateCompany);
//Assert
Assert.True(result.IsValid);
//Arrange
updateCompany.CountryId = Guid.NewGuid();
//Act
result = validator.Validate(updateCompany);
//Assert
Assert.False(result.IsValid);
}
public async Task Should_return_updated_company_when_update_company_with_certain_id()
{
await client.DeleteAsync("Companies/clear");
var company1 = new Company("Sun");
var company2 = new Company("Moon");
var updateCompany = new UpdateCompany("star");
string request1 = JsonConvert.SerializeObject(company1);
string request2 = JsonConvert.SerializeObject(company2);
string updateRequest = JsonConvert.SerializeObject(updateCompany);
StringContent requestBody1 = new StringContent(request1, Encoding.UTF8, "application/json");
StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
StringContent updateRequestBody = new StringContent(updateRequest, Encoding.UTF8, "application/json");
//when
var responseWithId = await client.PostAsync("/Companies", requestBody1);
await client.PostAsync("/Companies", requestBody2);
responseWithId.EnsureSuccessStatusCode();
var responseStringWithId = await responseWithId.Content.ReadAsStringAsync();
Company actualWithId = JsonConvert.DeserializeObject <Company>(responseStringWithId);
var id = actualWithId.Id;
var response = await client.PatchAsync($"/Companies/{id}", updateRequestBody);
//then
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
Company actual = JsonConvert.DeserializeObject <Company>(responseString);
company1.Name = "star";
Assert.Equal(company1, actual);
}
public bool UpdateCompany(Company c)
{
AbstractGenericOperation ado = new UpdateCompany();
bool success = (bool)ado.ExecuteSO(c);
return(success);
}
public Company UpdateCompanyInformation(string companyId, UpdateCompany updateCompany)
{
int index = companies.IndexOf(companies.Find(company => company.Id == companyId));
companies[index].Name = updateCompany.Name;
return(companies[index]);
}
public async Task <IActionResult> Update(long id, [FromBody] UpdateCompany command)
{
if (!ModelState.IsValid)
{
return(await Task.FromResult(Ok(ModelState.Values.SelectMany(e => e.Errors).Select(e => e.ErrorMessage))));
}
await _companyService.UpdateAsync(id, command);
return(NoContent());
}
public IActionResult UpdateCompanById(string id, UpdateCompany updateCompany)
{
var neetToUpdate = companies.First(company => company.Id == id);
if (neetToUpdate == null)
{
return(NotFound());
}
neetToUpdate.Name = updateCompany.Name;
return(Ok(neetToUpdate));
}
public void CanValidateName(string name, bool expected)
{
IValidator <UpdateCompany> validator = GetValidator();
UpdateCompany updateCompany = new UpdateCompany
{
Id = serviceMockFactory.CompanyMock.ValidId,
Name = name
};
//Act
ValidationResult result = validator.Validate(updateCompany);
//Assert
Assert.Equal(result.IsValid, expected);
}
public async Task UpdateAsync(long id, UpdateCompany dto)
{
var company = await _companyRepository.GetOrFailAsync(id);
company.SetName(dto.Name);
company.SetEstablishmentYear((int)dto.EstablishmentYear);
var employeesToDelete = company.Employees.ToList();
company.DeleteEmployees(employeesToDelete);
IEnumerable <Employee> employees = Enumerable.Empty <Employee>();
if (dto.Employees != null)
{
employees = dto.Employees.Select(d => new Employee(d.FristName, d.LastName, d.DateOfBirth, d.JobTitle.ToEnum()));
}
company.AddEmployees(employees);
await _companyRepository.UpdateAsync(company);
}
public IApiResult Update(UpdateCompany operation)
{
var result = operation.ExecuteAsync().Result;
if (result is ValidationsOutput)
{
return(new ApiResult <List <ValidationItem> >()
{
Data = ((ValidationsOutput)result).Errors
});
}
else
{
return(new ApiResult <object>()
{
Status = ApiResult <object> .ApiStatus.Success
});
}
}
public void CanValidateAddress(string street, string city, string zipCode, bool expected)
{
//Arrange
IValidator <UpdateCompany> validator = GetValidator();
UpdateCompany updateCompany = new UpdateCompany
{
Id = serviceMockFactory.CompanyMock.ValidId,
Name = "Test Name",
CountryId = serviceMockFactory.CountryMock.ValidId,
Address = new Address {
Street = street, City = city, ZipCode = zipCode
}
};
//Act
ValidationResult result = validator.Validate(updateCompany);
//Assert
Assert.Equal(result.IsValid, expected);
}
public async Task <IActionResult> UpdateCompany([FromBody] UpdateCompany company, [FromRoute] long id)
{
var exist = await _companyService.CompanyExist(id);
if (!exist)
{
return(StatusCode(404));
}
try
{
var mapped = _mapper.Map <UpdateCompanyDTO>(company);
await _companyService.UpdateCompany(mapped, id);
return(StatusCode(200));
}
catch (Exception e)
{
Console.WriteLine(e);
return(StatusCode(500));
}
}
public virtual IHttpActionResult Put(long id, [FromBody] UpdateCompany value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Company model = repository.GetByID(id);
try
{
model.Update(value);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
repository.Update(model);
return(Content(HttpStatusCode.NoContent, ""));
}
public async Task <IActionResult> Put(Guid id, UpdateCompany command)
=> await SendAsync(command.Bind(c => c.Id, id),
resourceId : command.Id, resource : "companies");
