public async Task <IActionResult> Update(string idContato, ContatoDto model)
{
try
{
var erros = ValidateHelpers.ValidateErrors(model);
if (erros.Count > 0)
{
return(BadRequest(erros));
}
var contato = await _repository.GetById(idContato);
if (contato == null)
{
return(NotFound(new Error(404, "Contato não encontrato.")));
}
model.Id = contato.Id;
_mapper.Map(model, contato);
_repository.Update(contato);
if (await _repository.SaveChangesAsync())
{
return(Ok(_mapper.Map <ContatoDto>(contato)));
}
}
catch (Exception ex)
{
throw ex;
}
return(BadRequest());
}
public async Task <IActionResult> Insert(ContatoDto model)
{
try
{
var erros = ValidateHelpers.ValidateErrors(model);
if (erros.Count > 0)
{
return(BadRequest(erros));
}
var contato = _mapper.Map <Contato>(model);
_repository.Add(contato);
if (await _repository.SaveChangesAsync())
{
return(Created($"/contato/{contato.Id}", _mapper.Map <ContatoDto>(contato)));
}
}
catch (Exception ex)
{
throw ex;
}
return(BadRequest());
}
public async Task <ActionResult> Put(int ContatoId, ContatoDto model)
{
try
{
var Contato = await _repo.GetContatoAsyncById(ContatoId);
if (Contato == null)
{
return(NotFound());
}
_map.Map(model, Contato);
_repo.Update(Contato);
if (await _repo.SaveChangesAsync())
{
return(Created($"/Contato/{model.Id}", _map.Map <ContatoDto>(Contato)));
}
}
catch (System.Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
return(BadRequest());
}
public ContatoDto MapperEntityToDto(Contato contato)
{
var contatoDto = new ContatoDto()
{
Id = contato.Id,
PessoaId = contato.PessoaId,
PessoasFisicas = contato.PessoasFisicas
};
return(contatoDto);
}
public void CadastrarUsuario(ContatoDto contato)
{
ContatoRepository contatoRepository = new ContatoRepository();
var contatoDados = new Contato
{
Nome = contato.Nome,
TelefoneResidencial = contato.TelefoneResidencial,
TelefoneCelular = contato.TelefoneCelular
};
contatoRepository.CadastrarUsuario(contatoDados);
}
public ActionResult Save(ContatoDto model)
{
if (ModelState.IsValid)
{
var Contato = new Contato();
_Contato.Save(model);
return(RedirectToAction("List"));
}
else
{
return(RedirectToAction("Create", model));
}
}
public IActionResult Post(ContatoDto model)
{
try
{
Console.WriteLine("Realizando contato...");
//TODO: fazer a implementação aqui do contato
return(Created($"/api/conato/{model.Email}", model));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Falha na execução do do contato"));
}
}
public JsonResult CadastrarUsuario(ContatoDto contato)
{
try
{
CadastroServico cadastroServico = new CadastroServico();
cadastroServico.CadastrarUsuario(contato);
return(Json(new { mensagem = "Usuario cadastrado com sucesso!" }));
}
catch (Exception ex)
{
return(Json(new { mensagem = ex.Message }));
}
}
private void NovoContatoForm_Shown(object sender, EventArgs e)
{
if (idParaEdicao == 0)
{
return;
}
ContatoDto contato = service.Get(idParaEdicao);
txtNome.Text = contato.Nome;
txtNome.Enabled = false;
txtEmail.Text = contato.Email;
txtTelefone.Text = contato.Telefone;
}
public ActionResult Delete([FromBody] ContatoDto contatoDto)
{
try
{
if (contatoDto == null)
{
return(NotFound());
}
applicationServiceContato.Remove(contatoDto);
return(Ok("Cadastro Removido com sucesso!"));
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Put([FromBody] ContatoDto contatoDto)
{
try
{
if (contatoDto == null)
{
return(NotFound());
}
applicationServiceContato.Update(contatoDto);
return(Ok("Cadastro Atualizado com sucesso!"));
}
catch (Exception)
{
throw;
}
}
public ActionResult Post([FromBody] ContatoDto contatoDTO)
{
try
{
if (contatoDTO == null)
{
return(NotFound());
}
applicationServiceContato.Add(contatoDTO);
return(Ok("Contato Cadastrado com sucesso!"));
}
catch (Exception ex)
{
throw ex;
}
}
public ContatoDto ListarUsuarios()
{
ContatoRepository contatoRepository = new ContatoRepository();
ContatoDto contatoDto = new ContatoDto();
var retorno = contatoRepository.ListarUsuarios();
foreach (var item in retorno)
{
contatoDto = new ContatoDto
{
Nome = item.Nome,
TelefoneResidencial = item.TelefoneResidencial,
TelefoneCelular = item.TelefoneCelular
};
}
return(contatoDto);
}
public async Task <ActionResult> Post(ContatoDto model)
{
try
{
var modelo = _map.Map <Contato>(model);
_repo.Add(modelo);
if (await _repo.SaveChangesAsync())
{
return(Created($"/Contato/{modelo.Id}", _map.Map <ContatoDto>(modelo)));
}
}
catch (System.Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError));
}
return(BadRequest());
}
public void CriarContato()
{
try
{
var dto = new ContatoDto();
dto.Nome = "Ricardo";
dto.SobreNome = "Oliveira";
dto.Cpf = "11690048492";
dto.Email = "*****@*****.**";
dto.Email2 = "*****@*****.**";
IHandler <ContatoDto> handler = new ContatoHandlers(_repositorio);
var result = handler.Create(dto);
Assert.True(result.Erros.Count == 0);
}
catch (Exception ex)
{
throw ex;
}
}
public OperationResult Update(ContatoDto contatoDto)
{
Contato contato = null;
try
{
contato = new Contato(contatoDto.Id, contatoDto.Nome, contatoDto.Telefone, contatoDto.Email);
}
catch (ArgumentException e)
{
return(new OperationResult(false, e.Message));
}
try
{
repo.Update(contato);
}
catch (Exception e)
{
return(new OperationResult(false, e.Message));
}
return(new OperationResult(true, null));
}
public List <ContatoDto> GetAll()
{
var contatos = _contatoService.GetAll();
return(ContatoDto.Convert(contatos));
}
public void Update(ContatoDto contatoDto)
{
var contatos = mapperContato.MapperDtoToEntity(contatoDto);
serviceContato.Update(contatos);
}
public void Remove(ContatoDto contatoDto)
{
var contatos = mapperContato.MapperDtoToEntity(contatoDto);
serviceContato.Remove(contatos);
}
/// <summary>
/// Salva e retorna o objeto<T> salvo
/// </summary>
public virtual ContatoDto SaveGetItem(ContatoDto model)
{
_unitOfWork.GetRepository <ContatoDto>().Add(model);
return(model);
}
public static List <Error> ValidateErrors(ContatoDto model)
{
var erros = new List <Error>();
if (string.IsNullOrEmpty(model.Canal))
{
erros.Add(new Error {
StatusCode = 400,
Message = "O campo Canal não pode ser vazio."
});
}
if (!Enum.IsDefined(typeof(CanalEnum), model.Canal))
{
var values = Enum.GetNames(typeof(CanalEnum));
erros.Add(new Error {
StatusCode = 400,
Message = $"O campo Canal permite apenas os seguinte valores: {string.Join(",", values)}"
});
}
if (string.IsNullOrEmpty(model.Valor))
{
erros.Add(new Error {
StatusCode = 400,
Message = "O campo Valor não pode ser vazio."
});
}
if (model.Canal == CanalEnum.Email.ToString())
{
var isValid = Utility.IsEmail(model.Valor);
if (!isValid)
{
erros.Add(new Error {
StatusCode = 400,
Message = "O campo Valor para o canal Email é inválido."
});
}
}
if (model.Canal == CanalEnum.Phone.ToString())
{
var isValid = Utility.IsPhone(model.Valor);
if (!isValid || model.Valor.Trim().Length != 15)
{
erros.Add(new Error {
StatusCode = 400,
Message = "O campo Valor para o canal Phone é inválido. Formato: (xx) xxxxx-xxxx ."
});
}
}
if (model.Canal == CanalEnum.PhoneFixo.ToString())
{
var isValid = Utility.IsPhone(model.Valor);
if (!isValid || model.Valor.Trim().Length != 14)
{
erros.Add(new Error {
StatusCode = 400,
Message = "O campo Valor para o canal PhoneFixo é inválido. Formato: (xx) xxxx-xxxx ."
});
}
}
return(erros);
}
private void btnSalvar_Click(object sender, EventArgs e)
{
string nome = txtNome.Text.Trim();
if (nome == string.Empty)
{
// TODO remover duplicação de código
MessageBox.Show(
"Nome deve ser informado.",
"ProjetoCSharp",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
txtNome.Select();
return;
}
string telefone = txtTelefone.Text.Trim();
if (telefone == string.Empty)
{
MessageBox.Show(
"Telefone deve ser informado.",
"ProjetoCSharp",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
txtTelefone.Select();
return;
}
string email = txtEmail.Text.Trim();
if (email != string.Empty && !email.Contains("@"))
{
MessageBox.Show(
"E-mail precisa ser válido (conter uma @).",
"ProjetoCSharp",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
txtEmail.Select();
return;
}
var contato = new ContatoDto
{
Id = idParaEdicao,
Nome = nome,
Email = email,
Telefone = telefone
};
OperationResult result = idParaEdicao == 0 ? service.Save(contato) : service.Update(contato);
if (result.Success)
{
MessageBox.Show(
"Contato salvo com sucesso.",
"ProjetoCSharp",
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
else
{
MessageBox.Show(
result.ErrorMessage,
"ProjetoCSharp",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
Close();
}
/// <summary>
/// Salva um objeto<T>
/// </summary>
public virtual void Save(ContatoDto model)
{
_unitOfWork.GetRepository <ContatoDto>().Add(model);
}
public async Task <ActionResult <ContatoViewModel> > Editar([FromBody] ContatoDto contato)
{
var userEtity = await _contatoServico.EditarAsync(_mapper.Map <Contato>(contato)).ConfigureAwait(false);
return(Ok(_mapper.Map <ContatoViewModel>(userEtity)));
}
/// <summary>
/// Salva a edição de um objeto<T>
/// </summary>
public virtual void Update(ContatoDto model)
{
_unitOfWork.GetRepository <ContatoDto>().Update(model);
}
public void Add(ContatoDto contatoDto)
{
var contatos = mapperContato.MapperDtoToEntity(contatoDto);
serviceContato.Add(contatos);
}
