public async Task Should_Update_Company_Property_When_Patch_UpdateCompany()
{
// given
await testClient.DeleteAsync("companies/clear");
Company company1 = new Company("0", "Baymax");
string request1 = JsonConvert.SerializeObject(company1);
StringContent requestBody1 = new StringContent(request1, Encoding.UTF8, "application/json");
await testClient.PostAsync("/companies", requestBody1);
// when
CompanyUpdateModel companyUpdateModel = new CompanyUpdateModel("GE");
string requestPatch = JsonConvert.SerializeObject(companyUpdateModel);
StringContent requestPatchBody = new StringContent(requestPatch, Encoding.UTF8, "application/json");
var response = await testClient.PatchAsync("companies/0", requestPatchBody);
// then
response.EnsureSuccessStatusCode();
var getResponse = await testClient.GetAsync("companies/0");
var getResponseString = await getResponse.Content.ReadAsStringAsync();
var actualCompany = JsonConvert.DeserializeObject <Company>(getResponseString);
Assert.Equal(new Company("0", "GE"), actualCompany);
}
public async Task Should_delete_company()
{
// given
CompanyUpdateModel companyUpdateModel = new CompanyUpdateModel(name: "Apple");
string request = JsonConvert.SerializeObject(companyUpdateModel);
StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");
await client.PostAsync("companies", requestBody);
EmployeeUpdateModel employeeUpdateModel = new EmployeeUpdateModel(name: "Steve", salary: 100);
string request2 = JsonConvert.SerializeObject(employeeUpdateModel);
StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
await client.PostAsync("companies/Apple/employees", requestBody2);
// when
await client.DeleteAsync("companies/Apple");
var response = await client.GetAsync("companies");
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
List <Company> actualEmployees = JsonConvert.DeserializeObject <List <Company> >(responseString);
// then
Assert.Equal(new List <Company>(), actualEmployees);
}
public async Task <CompanyResponseModel> UpdateAsync(Guid id, CompanyUpdateModel model)
{
var newCompany = _mapper.Map <Company>(model);
var updatedCompany = await _companyService.UpdateAsync(id, newCompany);
return(_mapper.Map <CompanyResponseModel>(updatedCompany));
}
public Company UpdateCompany(string companyId, CompanyUpdateModel updateModel)
{
var company = companies.GetCompanyByID(companyId);
company.Name = updateModel.Name;
return(company);
}
public async Task Should_change_employee_information()
{
// given
CompanyUpdateModel companyUpdateModel = new CompanyUpdateModel(name: "Apple");
string request = JsonConvert.SerializeObject(companyUpdateModel);
StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");
await client.PostAsync("companies", requestBody);
EmployeeUpdateModel employeeUpdateModel = new EmployeeUpdateModel(name: "Steve", salary: 100);
string request2 = JsonConvert.SerializeObject(employeeUpdateModel);
StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
await client.PostAsync("companies/Apple/employees", requestBody2);
// when
EmployeeUpdateModel employeeUpdateModel3 = new EmployeeUpdateModel(name: "Jobs", salary: 200);
string request3 = JsonConvert.SerializeObject(employeeUpdateModel3);
StringContent requestBody3 = new StringContent(request3, Encoding.UTF8, "application/json");
var response = await client.PatchAsync("companies/Apple/employees/Steve", requestBody3);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
Employee actualEmployees = JsonConvert.DeserializeObject <Employee>(responseString);
// then
Assert.Equal(new Employee(name: "Jobs", salary: 200), actualEmployees);
}
public async Task Should_change_company_name()
{
// given
CompanyUpdateModel companyUpdateModel = new CompanyUpdateModel(name: "Apple");
string request = JsonConvert.SerializeObject(companyUpdateModel);
StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");
await client.PostAsync("companies", requestBody);
var getResponse = await client.GetAsync("companies/Apple");
getResponse.EnsureSuccessStatusCode();
var responseString = await getResponse.Content.ReadAsStringAsync();
Company expectedCompany = JsonConvert.DeserializeObject <Company>(responseString);
// when
CompanyUpdateModel companyUpdateModel2 = new CompanyUpdateModel(name: "Banana");
string request2 = JsonConvert.SerializeObject(companyUpdateModel2);
StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
var patchResponse = await client.PatchAsync("companies/Apple", requestBody2);
patchResponse.EnsureSuccessStatusCode();
var responseString2 = await patchResponse.Content.ReadAsStringAsync();
Company actualCompany = JsonConvert.DeserializeObject <Company>(responseString2);
// then
Assert.Equal(new Company(name: "Banana"), actualCompany);
Assert.Equal(expectedCompany.Id, actualCompany.Id);
}
public IActionResult Add()
{
var model = new CompanyUpdateModel();
model.Roles = model.GetAllRoles();
return(View(model));
}
public async void Should_Get_Updated_Company()
{
// given
Company company = new Company("company_name_1");
string request = JsonConvert.SerializeObject(company);
StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");
// when
await client.PostAsync("company/companies", requestBody);
string companyID = "company_1";
string newName = "Changed_Name";
CompanyUpdateModel updateModel = new CompanyUpdateModel(newName);
string updateRequest = JsonConvert.SerializeObject(updateModel);
StringContent updateRequestBody = new StringContent(updateRequest, Encoding.UTF8, "application/json");
var response = await client.PatchAsync($"company/companies/{companyID}", updateRequestBody);
// then
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
Company actualCompany = JsonConvert.DeserializeObject <Company>(responseString);
Company expectedCompany = new Company(companyID, newName);
Assert.Equal(expectedCompany, actualCompany);
var queryResponse = await client.GetAsync($"company/companies/{companyID}");
var queryResponseString = await queryResponse.Content.ReadAsStringAsync();
Company queriedCompany = JsonConvert.DeserializeObject <Company>(queryResponseString);
Assert.Equal(expectedCompany, queriedCompany);
}
public async Task <IActionResult> Put(Guid id, CompanyUpdateModel model)
{
var updatedCompany = await _companyService.UpdateAsync(id, model);
var response = new Response(updatedCompany);
return(Ok(response));
}
public async Task <Company> InsertAsync(CompanyUpdateModel company)
{
var result = await this.Context.AddAsync(this.Mapper.Map <DataAccess.Entities.Company>(company));
await this.Context.SaveChangesAsync();
return(this.Mapper.Map <Company>(result.Entity));
}
public async Task <IActionResult> Update([FromBody] CompanyUpdateModel model)
{
_logger.LogInformation($"Update new videoGame : {HttpContext.Request.Query} ");
if (await _service.UpdateAsync(_mapper.Map <CompanyDTO>(model)))
{
return(Ok());
}
return(BadRequest());
}
public IActionResult Update()
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var model = new CompanyUpdateModel();
model.GetDropDownList(userId);
model.Load(userId);
return(View(model));
}
public async Task <ActionResult> UpdateCompany(string id, CompanyUpdateModel companyUpdateModel)
{
if (companies.Count != 0 && companies.Where(idCompanyPair => idCompanyPair.Value.Name == companyUpdateModel.Name).ToList().Count > 0)
{
return(Conflict());
}
companies.FirstOrDefault(idCompanyPair => idCompanyPair.Value.CompanyID == id).Value.Name =
companyUpdateModel.Name;
return(Ok());
}
public async Task <ActionResult <Company> > AddCompany(CompanyUpdateModel companyUpdateModel)
{
if (companies.Where(c => c.Name == companyUpdateModel.Name).Count() > 0)
{
return(Conflict());
}
var company = new Company(companyUpdateModel.Name);
companies.Add(company);
return(Ok(company));
}
public async Task <Company> UpdateAsync(CompanyUpdateModel company)
{
var existing = await this.Get(company);
var result = this.Mapper.Map(company, existing);
this.Context.Update(result);
await this.Context.SaveChangesAsync();
return(this.Mapper.Map <Company>(result));
}
public async Task <IActionResult> Add(CompanyUpdateModel model)
{
if (ModelState.IsValid)
{
if (string.IsNullOrWhiteSpace(model.Name))
{
await model.UserAssignToRoles();
}
else
{
await model.AddNewCompany();
}
}
model.Roles = model.GetAllRoles();
return(View(model));
}
public async Task Should_add_new_company()
{
// given
CompanyUpdateModel companyUpdateModel = new CompanyUpdateModel(name: "Apple");
string request = JsonConvert.SerializeObject(companyUpdateModel);
StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");
// when
var response = await client.PostAsync("companies", requestBody);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
Company actualCompany = JsonConvert.DeserializeObject <Company>(responseString);
// then
Assert.Equal(new Company(name: "Apple"), actualCompany);
}
public IActionResult UpdateCompany([FromBody] CompanyUpdateModel companyUpdateModel)
{
if (companyUpdateModel == null)
{
return(NoContent());
}
bool check = _companyLogic.UpdateCompany(companyUpdateModel);
if (check)
{
return(Ok("Update Company Successful"));
}
else
{
return(BadRequest("Cannot Update Company"));
}
}
public async Task <string> UpdateCompany(CompanyUpdateModel model)
{
var company = _CompanyRepository.GetById(model.CompanyId);
if (company == null)
{
return(ApiResponse.Error("Company Not Exits"));
}
company.CompanyName = model.CompanyName;
company.Address = model.Address;
company.Capital = model.Capital;
company.TotalShares = model.TotalShares;
company.OptionPoll = model.OptionPoll;
_CompanyRepository.Insert(company);
await _UnitOfWork.CommitAsyn();
return(ApiResponse.Ok());
}
public async Task Should_query_company_by_pageSize_and_pageIndex()
{
// given
CompanyUpdateModel companyUpdateModel = new CompanyUpdateModel(name: "Apple");
string request = JsonConvert.SerializeObject(companyUpdateModel);
StringContent requestBody = new StringContent(request, Encoding.UTF8, "application/json");
await client.PostAsync("companies", requestBody);
CompanyUpdateModel companyUpdateModel2 = new CompanyUpdateModel(name: "Banana");
string request2 = JsonConvert.SerializeObject(companyUpdateModel2);
StringContent requestBody2 = new StringContent(request2, Encoding.UTF8, "application/json");
await client.PostAsync("companies", requestBody2);
CompanyUpdateModel companyUpdateModel3 = new CompanyUpdateModel(name: "Orange");
string request3 = JsonConvert.SerializeObject(companyUpdateModel3);
StringContent requestBody3 = new StringContent(request3, Encoding.UTF8, "application/json");
await client.PostAsync("companies", requestBody3);
// when
var response = await client.GetAsync("companies?pageSize=1&pageIndex=2");
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
List <Company> actualCompany = JsonConvert.DeserializeObject <List <Company> >(responseString);
// then
Assert.Equal(new List <Company> {
new Company(name: "Banana")
}, actualCompany);
// when
var response2 = await client.GetAsync("companies?pageSize=2&pageIndex=2");
response.EnsureSuccessStatusCode();
var responseString2 = await response2.Content.ReadAsStringAsync();
List <Company> actualCompany2 = JsonConvert.DeserializeObject <List <Company> >(responseString2);
// then
Assert.Equal(new List <Company> {
new Company(name: "Orange")
}, actualCompany2);
}
public async Task <ActionResult> Update(int id, CompanyUpdateModel updateModel)
{
if (id < 1)
{
return(NotFound(new { Message = "Company not found" }));
}
// validate updateModel properties here
if (string.IsNullOrWhiteSpace(updateModel.Name))
{
return(BadRequest(new { Message = "Name is invalid" }));
}
await _companyRepository.Update(id, updateModel);
await _companyRepository.Commit();
return(Ok());
}
public IActionResult UpdateCompany(int id, [FromBody] CompanyUpdateModel model)
{
try
{
var userDto = new CompanyDto
{
Id = id,
Name = model.Name,
Type = model.Type,
Description = model.Description
};
var data = _service.UpdateCompany(userDto.Id, userDto);
return(Ok(data));
}
catch (ValidationException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IResultModel> Update(CompanyUpdateModel model)
{
var entity = await _repository.GetAsync(model.Id);
if (entity == null)
{
return(ResultModel.NotExists);
}
_mapper.Map(model, entity);
//if (await _repository.Exists(entity))
//{
//return ResultModel.HasExists;
//}
var result = await _repository.UpdateAsync(entity);
return(ResultModel.Result(result));
}
/// <summary>
/// Update the company information.
/// </summary>
/// <param name="id"></param>
/// <param name="model">The model.</param>
/// <returns></returns>
/// <exception cref="EntityNotFoundException">Company id {id} not found</exception>
public async Task <bool> UpdateCompany(Guid id, CompanyUpdateModel model)
{
// TODO check editable permission with user id
var company = _companyRepository.GetById(id);
if (company == null)
{
throw new EntityNotFoundException($"Company id {id} not found");
}
company.CompanyName = model.CompanyName;
company.CompanyDescription = model.CompanyDescription;
company.Address = model.Address;
company.Phone = model.Phone;
company.Capital = model.Capital;
company.TotalShares = model.TotalShares;
company.OptionPollAmount = model.OptionPoll;
_companyRepository.Update(company);
await _unitOfWork.CommitAsync();
return(true);
}
public bool UpdateCompany(CompanyUpdateModel companyUpdateModel)
{
bool check = false;
Company company = _unitOfWork.GetRepository <Company>().FindById(companyUpdateModel.CompanyId);
if (company != null)
{
company.CompanyId = companyUpdateModel.CompanyId;
company.Password = companyUpdateModel.Password;
company.CompanyName = companyUpdateModel.CompanyName;
company.Address = companyUpdateModel.Address;
company.Email = companyUpdateModel.Email;
company.Status = companyUpdateModel.Status;
company.Phone = companyUpdateModel.Phone;
company.Avatar = companyUpdateModel.Avatar;
_unitOfWork.GetRepository <Company>().Update(company);
_unitOfWork.Commit();
check = true;
}
return(check);
}
public async Task <IActionResult> Update(CompanyUpdateModel model)
{
try
{
string profileNewFileName, officeNewFileName;
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
profileNewFileName = await model.InsertImageToS3BucketAsync(model.ProfileImage);
officeNewFileName = await model.InsertImageToS3BucketAsync(model.OfficePhoto);
if (ModelState.IsValid)
{
model.AddTechnologyAreaOfOperation(userId);
model.EditCompany(profileNewFileName, officeNewFileName);
}
}
catch (Exception e)
{
throw e;
}
return(View(model));
}
public Task <Company> UpdateAsync(CompanyUpdateModel company)
{
return(CompanyDataAccess.UpdateAsync(company));
}
public async Task UpdateCompany([FromRoute] Guid id, [FromBody] CompanyUpdateModel model)
{
await _companyService.UpdateCompany(id, model);
Response.StatusCode = (int)HttpStatusCode.OK;
}
public Task <IResultModel> Update(CompanyUpdateModel model)
{
return(_service.Update(model));
}
public async Task <ActionResult <Company> > UpdateCompany(string companyName, CompanyUpdateModel companyUpdateModel)
{
var company = companies.FirstOrDefault(c => c.Name == companyName);
if (company == null)
{
return(NotFound());
}
company.Name = companyUpdateModel.Name;
return(Ok(company));
}
