public async Task <IActionResult> Create(DesenvolvedorInsertViewModel viewModel)
{
try
{
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <DesenvolvedorInsertViewModel, DesenvolvedorDTO>();
});
IMapper mapper = configuration.CreateMapper();
DesenvolvedorDTO desenvolvedor = mapper.Map <DesenvolvedorDTO>(viewModel);
await _desenvolvedorService.Create(desenvolvedor);
return(RedirectToAction("Index", "Home"));
}
catch (MSException ex)
{
ViewBag.ValidationErrors = ex.Errors;
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.Message;
}
return(View());
}
public async Task Create(DesenvolvedorDTO desenvolvedor)
{
ValidationResult result = new DesenvolvedorValidator().Validate(desenvolvedor);
result.ThrowExceptionIfFail();
await _desenvolvedorrepository.Create(desenvolvedor);
}
public async Task <IActionResult> Post([FromBody] DesenvolvedorDTO desenvolvedorDTO)
{
var aux = _unitOfWork.DesenvolvedorRepository.GetDesenvolvedorByCPF(desenvolvedorDTO.CPF);
if (aux != null)
{
return(Conflict("Já existe um desenvolvedor com esse CPF"));
}
try
{
Endereco endereco = new Endereco(desenvolvedorDTO.Logradouro, desenvolvedorDTO.Numero,
desenvolvedorDTO.CEP, desenvolvedorDTO.Bairro, desenvolvedorDTO.Cidade,
desenvolvedorDTO.Estado, desenvolvedorDTO.Pais);
Telefone telefone = new Telefone(desenvolvedorDTO.Tipo, desenvolvedorDTO.NumeroTelefone);
var user = new Desenvolvedor
{
Nome = desenvolvedorDTO.Nome,
Sobrenome = desenvolvedorDTO.Sobrenome,
CPF = desenvolvedorDTO.CPF,
LinkedinUrl = desenvolvedorDTO.LinkedinUrl,
DataContratacao = new DateTime(desenvolvedorDTO.DataContratacao.Ano,
desenvolvedorDTO.DataContratacao.Mes, desenvolvedorDTO.DataContratacao.Dia),
UserName = desenvolvedorDTO.Email,
Email = desenvolvedorDTO.Email,
EmailConfirmed = true,
Endereco = endereco,
Telefone = telefone
};
if (endereco == null || telefone == null || user == null)
{
return(BadRequest("Telefone ou endereço inválidos!"));
}
endereco.Desenvolvedor = user;
endereco.DesenvolvedorId = user.Id;
telefone.Desenvolvedor = user;
telefone.DesenvolvedorId = user.Id;
_unitOfWork.EnderecoRepository.Add(endereco);
_unitOfWork.TelefoneRepository.Add(telefone);
var result = await _userManager.CreateAsync(user, desenvolvedorDTO.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
_unitOfWork.Commit();
return(CreatedAtAction("Get", new { id = user.Id }, desenvolvedorDTO));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task Delete(DesenvolvedorDTO desenvolvedor)
{
DesenvolvedorDTO DbD = await _context.Desenvolvedoras.FirstOrDefaultAsync(u => u.ID == desenvolvedor.ID);
if (DbD != null)
{
_context.Desenvolvedoras.Remove(desenvolvedor);
await _context.SaveChangesAsync();
}
}
public async Task Create(DesenvolvedorDTO desenvolvedor)
{
try
{
_context.Desenvolvedoras.Add(desenvolvedor);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
throw new Exception("Erro no banco de dados");
}
}
public async Task <ICadastroSalvarResultado> UpdateAsync(DesenvolvedorDTO dto)
{
var objDesenvolvedor = _mapper.Map <Desenvolvedor>(dto);
if (!objDesenvolvedor.Validar(false))
{
return(new CadastroSalvarResultado(dto, objDesenvolvedor.Avisos, objDesenvolvedor.Erros));
}
await _servico.UpdateAsync(objDesenvolvedor);
var dtoRetorno = _mapper.Map <DesenvolvedorDTO>(objDesenvolvedor);
return(new CadastroSalvarResultado(dtoRetorno, objDesenvolvedor.Avisos, objDesenvolvedor.Erros));
}
public ICadastroSalvarResultado Inserir(DesenvolvedorDTO dto)
{
var objDesenvolvedor = _mapper.Map <Desenvolvedor>(dto);
if (!objDesenvolvedor.Validar(false))
{
return(new CadastroSalvarResultado(dto, objDesenvolvedor.Avisos, objDesenvolvedor.Erros));
}
_servico.Add(objDesenvolvedor);
var dtoRetorno = _mapper.Map <DesenvolvedorDTO>(objDesenvolvedor);
return(new CadastroSalvarResultado(dtoRetorno, objDesenvolvedor.Avisos, objDesenvolvedor.Erros));
}
public async Task <ActionResult> AdicionarDesenvolvedor([FromBody] DesenvolvedorDTO desenvolvedorDTO)
{
try
{
var resultado = await _appServicoDesenvolvedor.InserirAsync(desenvolvedorDTO);
if (resultado.ErroMensagem.Any())
{
return(StatusCode(400, resultado.MensagemErro400SalvandoCadastro()));
}
var desenvolvedorDtoResultado = (DesenvolvedorDTO)resultado.EntidadeDTO;
return(CreatedAtRoute("GetDesenvolvedor", new { id = desenvolvedorDtoResultado.Id }, desenvolvedorDtoResultado));
}
catch (Exception)
{
return(StatusCode(500, "Ocorreu uma falha inesperada. Entre em contato com o suporte técnico."));
}
}
public IActionResult Put(string id, DesenvolvedorDTO desenvolvedorDTO)
{
if (id != desenvolvedorDTO.Id)
{
return(BadRequest());
}
var desenvolvedor = _mapper.Map <Desenvolvedor>(desenvolvedorDTO);
Desenvolvedor aux = _unitOfWork.DesenvolvedorRepository.GetDesenvolvedorById(id);
desenvolvedor.Endereco = aux.Endereco;
desenvolvedor.Telefone = aux.Telefone;
Desenvolvedor aux2 = _unitOfWork.DesenvolvedorRepository.GetDesenvolvedorByCPF(desenvolvedor.CPF);
if (aux.CPF != desenvolvedor.CPF && desenvolvedor.CPF == aux2.CPF)
{
return(Conflict("O CPF não pode ser igual ao já cadastrado!"));
}
try
{
_unitOfWork.DesenvolvedorRepository.Update(desenvolvedor);
_unitOfWork.Commit();
var desenvolvedorResumoDTO = _mapper.Map <DesenvolvedorResumoDTO>(desenvolvedor);
return(Ok(desenvolvedorResumoDTO));
}
catch (DbUpdateConcurrencyException)
{
if (aux != null)
{
return(NoContent());
}
else
{
throw;
}
}
}
public async Task <ActionResult> AtualizarDesenvolvedor([FromBody] DesenvolvedorDTO desenvolvedorDTO)
{
try
{
if (!await _appServicoDesenvolvedor.ExistsAsync(desenvolvedorDTO.Id))
{
return(NotFound(StatusCode(400, $"Desenvolvedor não encontrado para o ID {desenvolvedorDTO.Id}.")));
}
var resultado = await _appServicoDesenvolvedor.UpdateAsync(desenvolvedorDTO);
if (resultado.ErroMensagem.Any())
{
return(StatusCode(400, resultado.MensagemErro400SalvandoCadastro()));
}
return(Ok(resultado));
}
catch (Exception)
{
return(StatusCode(500, "Ocorreu uma falha inesperada. Entre em contato com o suporte técnico."));
}
}
public Task Update(DesenvolvedorDTO desenvolvedor)
{
throw new NotImplementedException();
}
public async Task Delete(DesenvolvedorDTO desenvolvedor)
{
await _desenvolvedorrepository.Delete(desenvolvedor);
}
public async Task <string> GetDesenvolvedorById(int desebvolvedorId)
{
DesenvolvedorDTO DbD = await _context.Desenvolvedoras.FirstOrDefaultAsync(u => u.ID == desebvolvedorId);
return(DbD.Nome);
}
