public ActionResult CreateCompany(CreateCompanyDTO createCompany)
{
var createCompanyMapped = _mapper.Map <Company>(createCompany);
_companyService.CreateCompany(createCompanyMapped);
return(Ok());
}
public async Task <IActionResult> PostCompanies([FromBody] CreateCompanyDTO model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var fechaHora = DateTime.Now;
Company deathpeople = new Company
{
nombre = model.nombre,
descripcion = model.descripcion,
condicion = true,
idusuario = model.idusuario,
idcategoria = model.idcategoria
};
_context.Companies.Add(deathpeople);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest());
}
return(Ok());
}
[HttpPost("create company")] // CREATE
public ActionResult CreateCompany(CreateCompanyDTO newCompany)
{
var companyToAdd = _mapper.Map <Company>(newCompany);
_companyService.CreateCompany(companyToAdd);
return(Ok());
}
public async Task <long> CreateCompany(CreateCompanyDTO company)
{
var entity = _mapper.Map <Company>(company);
await _dbContext.Companies.AddAsync(entity);
await _dbContext.SaveChangesAsync();
return(entity.CompanyId);
}
public ActionResult UpdateCompany(int idCompanyToUpdate, CreateCompanyDTO newCompanyValues)
{
try
{
var companyMappedNewValues = _mapper.Map <Company>(newCompanyValues);
_companyService.UpdateCompanyById(idCompanyToUpdate, companyMappedNewValues);
return(Ok());
}
catch (KeyNotFoundException)
{
return(NotFound());
}
}
[HttpPut("update company by id")] // UPDATE
public ActionResult UpdateCompanyById(int companyId, CreateCompanyDTO companyEditValues)
{
try
{
var companyToUpdate = _mapper.Map <Company>(companyEditValues);
_companyService.UpdateCompanyById(companyId, companyToUpdate);
return(Ok());
}
catch (InvalidOperationException)
{
return(NotFound());
}
}
public async Task <Guid> CreateCompanyAsync(CreateCompanyDTO company)
{
var entity = new Company
{
Id = company.Id,
Name = company.Name,
};
await context.Companies.AddAsync(entity);
await context.SaveChangesAsync();
return(entity.Id);
}
public async Task Create_returns_500_on_internal_error()
{
var company = new CreateCompanyDTO();
repository.Setup(r => r.CreateCompanyAsync(company)).ThrowsAsync(new Exception());
var controller = new CompanyRepositoryController(repository.Object);
var actual = await controller.Create(company, true);
var actionResult = Assert.IsType <ActionResult <Guid> >(actual);
var code = Assert.IsType <StatusCodeResult>(actionResult.Result);
Assert.Equal(500, code.StatusCode);
}
public async Task CreateCompany_returns_the_id_of_created_company()
{
var id = Guid.NewGuid();
var company = new CreateCompanyDTO
{
Id = id,
Name = "Test"
};
var actualId = await repository.CreateCompanyAsync(company);
var createdCompany = await Context.Companies.FindAsync(actualId);
Assert.Equal(company.Id, actualId);
Assert.Equal(company.Name, createdCompany.Name);
}
public async Task Create_returns_200_and_id_of_created_company()
{
var nextMockedId = Guid.NewGuid();
var company = new CreateCompanyDTO();
repository.Setup(r => r.CreateCompanyAsync(company)).ReturnsAsync(nextMockedId);
var controller = new CompanyRepositoryController(repository.Object);
var actual = await controller.Create(company, true);
var actionResult = Assert.IsType <ActionResult <Guid> >(actual);
var okResult = Assert.IsType <OkObjectResult>(actionResult.Result);
var actualId = Assert.IsType <Guid>(okResult.Value);
Assert.Equal(200, okResult.StatusCode);
Assert.Equal(nextMockedId, actualId);
}
public async Task <ActionResult <Guid> > Create([FromBody] CreateCompanyDTO company, bool isTest = false)
{
try
{
var id = await repository.CreateCompanyAsync(company);
return(Ok(id));
}
catch (ArgumentException e)
{
Util.LogError(e, isTest);
return(StatusCode(StatusCodes.Status409Conflict));
}
catch (Exception e)
{
Util.LogError(e, isTest);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
