public async Task Post_ContatoValido_DeveRetornar200()
{
var login = await Utils.RealizarLogin(Client);
var contato = new ContatoViewModel
{
Nome = "Teste",
Email = "*****@*****.**",
Endereco = new EnderecoViewModel
{
Logradouro = "Rua 1",
Bairro = "bairro",
CEP = "14778665",
Cidade = "cidade",
Estado = "SP",
Numero = "123"
}
};
var response = await Server
.CreateRequest("api/contatos")
.AddHeader("Authorization", "Bearer " + login.access_token)
.And(req => req.Content = Utils.GerarRequestContent(contato))
.PostAsync();
response.EnsureSuccessStatusCode();
var contatoResult = JsonConvert.DeserializeObject <ContatoJsonDTO>(await response.Content.ReadAsStringAsync());
Assert.Equal(contatoResult.data.nome, contato.Nome);
Assert.NotEmpty(contatoResult.data.id);
Assert.NotNull(contatoResult.data.id);
Assert.NotEmpty(contatoResult.data.enderecoId);
Assert.NotNull(contatoResult.data.enderecoId);
}
public ActionResult Alterar(string id)
{
var contato = repositorio.ObterPorId(id);
var contatoViewModel = new ContatoViewModel()
{
Email = contato.Email,
Nome = contato.Nome,
Id = contato.Id,
Telefone = contato.Telefone
};
if (contato is Empresa)
{
contatoViewModel.CNPJ = ((Empresa)contato).CNPJ;
}
else
{
contatoViewModel.CPF = ((Pessoa)contato).CPF;
contatoViewModel.RG = ((Pessoa)contato).RG;
contatoViewModel.DataNascimento = ((Pessoa)contato).DataNascimento;
}
return(View(contatoViewModel));
}
public ActionResult ExcluirContato(ContatoViewModel vm)
{
if ((String)Session["Ativa"] == null)
{
return(RedirectToAction("Login", "ControleAcesso"));
}
Int32 idAss = (Int32)Session["IdAssinante"];
try
{
// Executa a operação
USUARIO usuarioLogado = (USUARIO)Session["UserCredentials"];
CONTATO item = Mapper.Map <ContatoViewModel, CONTATO>(vm);
Int32 volta = baseApp.ValidateDelete(item, usuarioLogado, idAss);
// Verifica retorno
if (volta == 1)
{
Session["MensContato"] = 1;
ModelState.AddModelError("", SMS_Resource.ResourceManager.GetString("M0026", CultureInfo.CurrentCulture));
return(View(vm));
}
// Sucesso
listaMasterAss = new List <CONTATO>();
Session["ListaContato"] = null;
Session["MensContato"] = 0;
return(RedirectToAction("MontarTelaContato"));
}
catch (Exception ex)
{
ViewBag.Message = ex.Message;
return(View(vm));
}
}
private void InicializarApp()
{
if (ContatoVM == null)
{
ContatoVM = new ContatoViewModel();
}
}
public IActionResult Add(ContatoViewModel model)
{
if (ModelState.IsValid)
{
Contato c = null;
if (model.Id > 0)
{
c = contatoGerenciador.RecuperarPorId(model.Id);
}
else
{
c = new Contato();
}
c.Id = model.Id;
c.Celular = model.Celular;
c.Email = model.Email;
c.TelResidencia = model.TelResidencia;
contatoGerenciador.Add(c);
}
return(RedirectToAction("Index"));
}
public void SalvarContatoTest()
{
var classificacoes = MTechneContainer.Container.Resolve <IClassificacaoRepository>().GetAll();
var contato = new ContatoViewModel()
{
Nome = "Igor de Andrade Monteiro",
Empresa = "Empresa teste",
Endereco = "Rua teste 21, bairro teste São Paulo -SP",
Emails = new List <EmailContatoViewModel>()
{
// order by new guid para deixar embaralhado as classficacoes
new EmailContatoViewModel()
{
ClassificacaoId = classificacoes.OrderBy(x => new Guid()).FirstOrDefault().Id, Email = "*****@*****.**"
}
},
Telefones = new List <TelefoneContatoViewModel>()
{
new TelefoneContatoViewModel()
{
ClassificacaoId = classificacoes.OrderBy(x => new Guid()).FirstOrDefault().Id, Telefone = "11 4447-5153"
}
}
};
ContatoViewModel contatoSalvo = MTechneContainer.Container.Resolve <IContatoApplication>().Salvar(contato);
Assert.AreNotEqual(0, contatoSalvo.Id);
Assert.AreNotEqual(0, contatoSalvo.Telefones[0].Id);
Assert.AreNotEqual(0, contatoSalvo.Telefones[0].ContatoId);
Assert.AreNotEqual(0, contatoSalvo.Emails[0].Id);
Assert.AreNotEqual(0, contatoSalvo.Emails[0].ContatoId);
}
public ActionResult Atualizar(int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Index)));
}
var contato = _contatoRepositorio.ObterContatoPorId(id.Value);
if (contato == null)
{
RegistroNaoEncontrado();
}
var viewModel = new ContatoViewModel
{
Id = contato.Id,
Nome = contato.Nome,
Sobrenome = contato.Sobrenome,
Email = contato.Email,
Cargo = contato.Cargo,
Celular = contato.Celular,
Departamento = contato.Departamento,
Telefone = contato.Telefone,
DataNascimento = contato.DataNascimento,
Status = contato.Status,
ContaId = contato.ContaId
};
PopularContas(viewModel);
return(View(viewModel));
}
public ContatoViewModel Salvar(ContatoViewModel viewModel)
{
var contato = Mapper.Map <Contato>(viewModel);
var contatoVm = Mapper.Map <ContatoViewModel>(_contatoRepository.Salvar(contato));
return(contatoVm);
}
public ActionResult Editar(ContatoViewModel contato)
{
if (ModelState.IsValid)
{
var claimsIdentity = User.Identity as ClaimsIdentity;
int usuarioId = 0;
int.TryParse(claimsIdentity.FindFirst("Id").Value, out usuarioId);
var contatoMember = new WCF.DataContracts.Contato
{
Id = contato.Id,
Email = contato.Email,
Nome = contato.Nome,
Telefone = contato.Telefone,
UsuarioId = usuarioId
};
if (contatoCliente.AlterarContato(contatoMember))
{
return(Json(contato.Id));
}
}
return(View(contato));
}
public ActionResult Index(ContatoViewModel model)
{
var recaptchaHelper = this.GetRecaptchaVerificationHelper();
if (string.IsNullOrEmpty(recaptchaHelper.Response))
{
ModelState.AddModelError("", "O captcha é obrigatório.");
return(View(model));
}
var recaptchaResult = recaptchaHelper.VerifyRecaptchaResponse();
if (recaptchaResult != RecaptchaVerificationResult.Success)
{
ModelState.AddModelError("", "Captcha incorreto.");
return(View(model));
}
if (ModelState.IsValid)
{
var entity = Mapper.Map <Contato>(model);
_contatoRepository.Add(entity);
TempData.Add("Message", "Seu contato foi recebido com sucesso! Em breve estaremos respondendo a sua dúvida!");
return(RedirectToAction("Index", "Home", null));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ContatoViewModel Atualizar(Guid id, ContatoViewModel viewModel)
{
var contato = Mapper.Map <Contato>(viewModel);
var contatoVm = Mapper.Map <ContatoViewModel>(_contatoRepository.Atualizar(id, contato));
return(contatoVm);
}
public async Task SendEmailHelpDesk(ContatoViewModel contato)
{
try
{
MailMessage mail = new MailMessage()
{
From = new MailAddress(contato.Email)
};
mail.To.Add(new MailAddress("*****@*****.**"));
mail.Body = contato.Message;
mail.Subject = contato.Subject;
mail.SubjectEncoding = Encoding.GetEncoding("ISO-8859-1");
mail.IsBodyHtml = true;
mail.Priority = MailPriority.High;
using (SmtpClient smtp = new SmtpClient(_emailSettings.PrimaryDomain,
_emailSettings.PrimaryPort))
{
smtp.Credentials = new NetworkCredential(_emailSettings.UsernameEmail,
_emailSettings.UsernamePassword);
smtp.EnableSsl = true;
await smtp.SendMailAsync(mail);
}
}
catch (Exception ex)
{
throw new Exception(ex.ToString());
}
}
public IActionResult AddContatoEmail(ContatoViewModel contatoViewModel)
{
if (TryValidateModel(contatoViewModel.ContatoEmail))
{
if (_contatoEmailViewModels == null)
{
_contatoEmailViewModels = new List <ContatoEmailViewModel>();
}
if (!string.IsNullOrEmpty(contatoViewModel.ContatoEmail.Email?.Trim() ?? "") && !_contatoEmailViewModels.Exists(x => x.Email == contatoViewModel.ContatoEmail.Email))
{
_contatoEmailViewModels.Add(new ContatoEmailViewModel()
{
Email = contatoViewModel.ContatoEmail.Email
});
contatoViewModel.ContatoEmail = new ContatoEmailViewModel();
}
else
{
ViewBag.Error = "Ja existe este Email.";
}
if (IsValidOperation())
{
ViewBag.Sucesso = "Email Cadastrado!";
}
_contatoViewModel = contatoViewModel;
}
return(RedirectToAction("Create"));
}
public IActionResult AddContatoTelefone(ContatoViewModel contatoViewModel)
{
if (TryValidateModel(contatoViewModel.ContatoTelefone))
{
if (_contatoTelefoneViewModels == null)
{
_contatoTelefoneViewModels = new List <ContatoTelefoneViewModel>();
}
if (!string.IsNullOrEmpty(contatoViewModel.ContatoTelefone.Telefone?.Trim() ?? "") && !_contatoTelefoneViewModels.Exists(x => x.Telefone == contatoViewModel.ContatoTelefone.Telefone))
{
_contatoTelefoneViewModels.Add(new ContatoTelefoneViewModel()
{
Telefone = contatoViewModel.ContatoTelefone.Telefone
});
contatoViewModel.ContatoTelefone = new ContatoTelefoneViewModel();
}
else
{
ViewBag.Error = "Ja existe este telefone.";
}
if (IsValidOperation())
{
ViewBag.Sucesso = "Telefone Cadastrado!";
}
_contatoViewModel = contatoViewModel;
}
return(RedirectToAction("Create"));
}
public JsonResult BuscarContato(int id)
{
try
{
ContatoRepositorio rep = new ContatoRepositorio();
Contato contato = rep.EncontrarPorId(id);
if (contato != null)
{
ContatoViewModel contatoViewModel = new ContatoViewModel()
{
IdContato = contato.IdContato,
Nome = contato.Nome,
Email = contato.Email,
Telefone = contato.Telefone
};
return(Json(new { sucesso = true, contato = contatoViewModel }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { sucesso = false, mensagem = "Não foi possível encontrar o registro na base de dados." }, JsonRequestBehavior.AllowGet));
}
}
catch (Exception e)
{
throw e;
}
}
public IActionResult FormUpdateContato(ContatoViewModel entrada)
{
Contato modelo = new Contato();
entrada.contexto = contexto;
try
{
if (ContatoRules.MontaContatoUpdate(entrada, out modelo))
{
contatoData.Update(modelo);
StatusMessage = "Registro Atualizado com Sucesso!";
return(RedirectToAction("FormUpdateContato", new { id = modelo.id.ToString(), idOrg = contexto.idOrganizacao }));
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 2, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormUpdateContato-post", ex.Message);
}
return(RedirectToAction("FormUpdateContato", new { id = modelo.id.ToString() }));
}
public ActionResult AdicionarContato(ContatoViewModel contatoViewModel)
{
if (ModelState.IsValid)
{
var contato = new Contato()
{
FornecedorId = contatoViewModel.FornecedorId,
Nome = contatoViewModel.Nome,
Email = contatoViewModel.Email,
Telefone1 = contatoViewModel.Telefone1,
Telefone2 = contatoViewModel.Telefone2,
Telefone3 = contatoViewModel.Telefone3
};
if (contato.Nome != null)
{
db.Contatos.Add(contato);
}
db.SaveChanges();
string url = Url.Action("ListarContatos", "Fornecedores", new { id = contatoViewModel.FornecedorId });
return(Json(new { success = true, url = url }));
}
return(PartialView("_AdicionarEndereco", contatoViewModel));
}
public IActionResult FormCreateContato(ContatoViewModel entrada)
{
Contato modelo = new Contato();
entrada.contexto = contexto;
try
{
if (entrada.contato != null)
{
if (ContatoRules.MontaContatoCreate(entrada, out modelo, contexto))
{
contatoData.Add(modelo);
return(RedirectToAction("FormUpdateContato", new { id = modelo.id.ToString() }));
}
}
}
catch (Exception ex)
{
LogOsca log = new LogOsca();
log.GravaLog(1, 2, this.contexto.idUsuario, this.contexto.idOrganizacao, "FormCreateContato-post", ex.Message);
}
return(View());
}
public void Devo_alterar_o_contato_ao_efetuar_um_Post_para_contatos_com_id_do_contato()
{
var controller = new ContatosController(Session);
Mapper.AddProfile <ContatoProfile>();
var contato = new Contato
{
Apelido = "Apelido",
Nome = "Nome"
};
Session.Store(contato);
Session.SaveChanges();
var viewModel = new ContatoViewModel
{
Apelido = "Apelido1",
Nome = "Nome1"
};
controller.Update(contato.Id, viewModel);
Session.SaveChanges();
Assert.That(Session.Load <Contato>(contato.Id).Nome,
Is.EqualTo(viewModel.Nome));
}
public ActionResult Excluir(string id)
{
var contato = contatoApp.ObterPorId(id);
var contatoViewModel = new ContatoViewModel()
{
Email = contato.Email,
Nome = contato.Nome,
Id = contato.Id,
Telefone = contato.Telefone
};
if (contato is Empresa)
{
contatoViewModel.CNPJ = ((Empresa)contato).CNPJ;
contatoViewModel.Tipo = PessoaFisicaJuridica.PessoaJuridica;
}
else
{
contatoViewModel.CPF = ((Pessoa)contato).CPF;
contatoViewModel.RG = ((Pessoa)contato).RG;
contatoViewModel.DataNascimento = ((Pessoa)contato).DataNascimento;
contatoViewModel.Tipo = PessoaFisicaJuridica.PessoaFisica;
}
return(View(contatoViewModel));
}
public ActionResult Cadastrar([Bind(Include = "Nome, Sobrenome, Telefone, Celular, Email, Cargo, Departamento, DataNascimento, Status, ContaId, TelaContas")] ContatoViewModel viewModel)
{
var contato = new Contato(
viewModel.Nome,
viewModel.Sobrenome,
viewModel.Telefone,
viewModel.Celular,
viewModel.Email,
viewModel.Cargo,
viewModel.Departamento,
viewModel.DataNascimento,
viewModel.Status,
viewModel.ContaId);
if (Validar(contato))
{
contato.Id = _contatoRepositorio.Cadastrar(contato);
TempData["Sucesso"] = true;
GravarLogAuditoria(TipoLogAuditoria.INSERT, contato);
}
PopularContas(viewModel);
return(View(viewModel));
}
public ActionResult Create(ContatoViewModel contatoViewModel)
{
if (!ModelState.IsValid)
{
return(View("New", contatoViewModel));
}
var contato = DocumentSession
.Query <Contato_Search.ContatoSearch, Contato_Search>()
.As <Contato>()
.FirstOrDefault(c => c.Nome == contatoViewModel.Nome);
if (null == contato)
{
contato = Mapper.Map <ContatoViewModel, Contato>(contatoViewModel);
DocumentSession.Store(contato);
TempData["success"] = "Contato incluido com sucesso";
}
else
{
TempData["error"] = string.Format("Já existe um contato com o nome {0}", contato.Nome);
}
return(RedirectToAction("Edit", new { contato.Id }));
}
public ContatoView()
{
InitializeComponent();
_viewModel = new ContatoViewModel();
BindingContext = _viewModel;
}
public async Task <ContatoViewModel> Incluir(ContatoViewModel pObj)
{
var objRetorno = new ContatoViewModel();
pObj.Idade = CalcularIdade(pObj);
objRetorno.Erro = Validacao.ValidarContato.ValidarDados(pObj);
if (objRetorno.Erro != "")
{
objRetorno.Erro = "Erro ao incluir dados! " + objRetorno.Erro;
}
else
{
try
{
var lObj = _mapper.Map <Contato>(pObj);
var result = await _contatoRepository.Insert(lObj);
objRetorno = _mapper.Map <ContatoViewModel>(lObj);
}
catch (Exception ex)
{
objRetorno.Erro = "Erro ao incluir dados! " + ex.Message;
}
}
return(objRetorno);
}
public void Post([FromBody] ContatoViewModel obj)
{
if (ModelState.IsValid)
{
_contato.Insert(_mapper.Map <Contato>(obj));
}
}
public async Task <ContatoViewModel> Excluir(int id)
{
var retorno = new ContatoViewModel();
try
{
var obj = _contatoRepository.GetById(id).Result;
if (obj == null)
{
retorno.Erro = "Contato não encontrado!";
}
else
{
_contatoRepository.Delete(obj);
await _contatoRepository.Commit();
}
}
catch (Exception ex)
{
retorno.Erro = "Erro ao excluir Contato! " + ex.Message;
}
return(retorno);
}
public ActionResult Alterar(ContatoViewModel contatoViewModel)
{
if (string.IsNullOrEmpty(contatoViewModel.Nome))
{
ModelState.AddModelError("Nome", "O nome deve ser informado");
}
if (ModelState.IsValid)
{
Contato contato;
if (contatoViewModel.Tipo == PessoaFisicaJuridica.PessoaFisica)
{
contato = new Pessoa();
((Pessoa)contato).RG = contatoViewModel.RG;
((Pessoa)contato).CPF = contatoViewModel.CPF;
((Pessoa)contato).DataNascimento = contatoViewModel.DataNascimento;
contato.Tipo = PessoaFisicaJuridica.PessoaFisica;
}
else
{
contato = new Empresa();
((Empresa)contato).CNPJ = contatoViewModel.CNPJ;
contato.Tipo = PessoaFisicaJuridica.PessoaJuridica;
}
contato.Id = contatoViewModel.Id;
contato.Nome = contatoViewModel.Nome;
contato.Telefone = contatoViewModel.Telefone;
contato.Email = contatoViewModel.Email;
contato.UsuarioId = usuario.Id;
repositorio.Alterar(contato);
return(RedirectToAction("Inicio"));
}
return(View(contatoViewModel));
}
private void InitializeApplication()
{
if (ContatoVM == null)
{
ContatoVM = new ContatoViewModel();
}
}
public ActionResult ReativarContato(ContatoViewModel vm)
{
if ((String)Session["Ativa"] == null)
{
return(RedirectToAction("Login", "ControleAcesso"));
}
Int32 idAss = (Int32)Session["IdAssinante"];
try
{
// Executa a operação
USUARIO usuarioLogado = (USUARIO)Session["UserCredentials"];
CONTATO item = Mapper.Map <ContatoViewModel, CONTATO>(vm);
Int32 volta = baseApp.ValidateReativar(item, usuarioLogado, idAss);
// Sucesso
listaMasterAss = new List <CONTATO>();
Session["ListaContato"] = null;
Session["MensContato"] = 0;
return(RedirectToAction("MontarTelaContato"));
}
catch (Exception ex)
{
ViewBag.Message = ex.Message;
return(View(vm));
}
}
//public ActionResult Contact(FormCollection formulario)
//public ActionResult Contact(string nome, string email, string mensagem)
public ActionResult Contact(ContatoViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var portfolioConnectionString = ConfigurationManager.ConnectionStrings["porftolioConnectionString"].ConnectionString;
using (var conexao = new SqlConnection(portfolioConnectionString))
{
conexao.Open();
const string instrucao = @"
INSERT INTO [dbo].[Contato]
([Nome]
,[Email]
,[Messagem])
VALUES
(@Nome
,@Email
,@Messagem) ";
using (var comando = new SqlCommand(instrucao, conexao))
{
comando.Parameters.AddWithValue("@Nome", viewModel.Nome);
comando.Parameters.AddWithValue("Email", viewModel.Email);
comando.Parameters.AddWithValue("@Messagem", viewModel.Mensagem);
comando.ExecuteNonQuery();
}
}
ModelState.Clear();
return(View());
}