public JsonResult ExcluirContato(ContatoModel alterarContato)
{
string conteudoRetorno = string.Empty;
string codigoRetorno = string.Empty;
var listaContatos = lerContatos();
var contato = listaContatos.Find(x => x.IdContato == alterarContato.IdContato);
listaContatos.Remove(contato);
var arquivoLista = JsonConvert.SerializeObject(listaContatos);
ArquivoHelper.GravarContato(arquivoLista);
codigoRetorno = "0";
conteudoRetorno = "Contato excluido com Sucesso!";
return(Json(new
{
codigo = codigoRetorno,
conteudo = conteudoRetorno
},
"application/json",
Encoding.UTF8,
JsonRequestBehavior.AllowGet));
}
public ActionResult DeletaContato(ContatoModel _contatoModel)
{
Contato _contato = new Contato();
_contato.DeletaContato(_contatoModel);
return(new HttpStatusCodeResult(200));
}
public void Listar()
{
var contato = new ContatoModel();
var listado = contato.Listar();
string x = "";
}
public void Criar(ContatoModel contato)
{
var contatos = recuperarTodos();
contatos.Add(contato);
EscreverArquivo(contatos);
}
public ActionResult Index()
{
using (ContatoModel model = new ContatoModel()) {
List <Contato> Lista = model.Read;
return(View(Lista));
}
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> Contact([FromBody] ContatoModel model)
{
try
{
if (ModelState.IsValid)
{
//var spamState = VerifyNoSpam(model);
//if (!spamState.Success)
//{
// return BadRequest(new { Reason = spamState.Reason });
//}
//await _emailService.EnviarEmail(model.Nome, model.Email, model.Assunto, model.Mensagem);
return(Ok(new { Success = true, Message = "E-mail enviado com sucesso" }));
}
else
{
return(BadRequest(new { Reason = "Desculpe... Falha ao enviar mensagem." }));
}
}
catch (Exception ex)
{
//_logger.LogError("Failed to send email from contact page", ex);
return(BadRequest(new { Reason = "Error Occurred" }));
}
}
public void IniciarProcessamento(ContatoModel contato_) {
var negociarCOntato = new ContatoBusiness();
negociarCOntato.ValidarCamposObrigatorios(contato_);
EmailHelper.Enviar("*****@*****.**", "*****@*****.**", "test", "MENSAGEM ERICK");
ArquivoHelper.GravarLog("Gravado com sucesso");
}
public ActionResult Edit(ContatoModel contatoModel)
{
try
{
contatoModel = _contatoAppService.Editar(contatoModel);
foreach (var erro in contatoModel.ListaErros)
{
ModelState.AddModelError(erro.Key, erro.Value);
}
if (ModelState.IsValid)
{
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(contatoModel));
}
}
catch
{
return(View());
}
}
// GET: Contato
public ActionResult Index(ContatoModel _contatoModel)
{
Contato _contato = new Contato();
var lista = _contato.ListaContatos(_contatoModel);
return(View(lista));
}
public ActionResult AdicionaContato(ContatoModel _contatoModel)
{
Contato _contato = new Contato();
var novoContato = _contato.AdicionaContato(_contatoModel);
return(base.RedirectToAction("Index", "Contato"));
}
public ActionResult AtualizaContato(ContatoModel _contatoModel)
{
Contato _contato = new Contato();
_contato.AtualizaContato(_contatoModel);
return(base.RedirectToAction("Index", "Contato"));
}
/// <summary>
/// Função para salvar os registros.
/// </summary>
/// <param name="nome"></param>
/// <param name="sobrenome"></param>
/// <param name="telefone"></param>
/// <param name="email"></param>
public void Save(string nome, string sobrenome, string telefone, string email)
{
contato = new ContatoModel(nome, sobrenome, telefone, email);
listContato.Add(contato);
Clear(nome, sobrenome, telefone, email);
//Message.SetAttach(null,"");
}
public IHttpActionResult PutContatoModel(int id, ContatoModel contatoModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != contatoModel.Id)
{
return(BadRequest());
}
db.Entry(contatoModel).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!ContatoModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void Editar(ContatoModel contato)
{
var contatos = recuperarTodos();
contatos.RemoveAll(c => c.Id == contato.Id);
contatos.Add(contato);
EscreverArquivo(contatos);
}
public void Testar_Camadas_Com_Padrao_Facade()
{
var novoContato = new ContatoModel();
novoContato.Nome = "Zeh";
novoContato.Email = "Email01";
var contatoFacade = new ContatoFacade();
contatoFacade.IniciarProcessamento(novoContato);
}
public static void ToEntity(ContatoModel model, TB_CONTATO registro)
{
registro.ID = model.Id;
registro.DS_EMAIL = model.Email;
registro.DS_TELEFONE = model.Telefone;
registro.DS_NASCIMENTO = model.DataNascimento;
registro.NM_CONTATO = model.Nome;
registro.ID_SEXO = model.Sexo.Id;
}
public void IniciarProcessamento(ContatoModel contato_)
{
var negociarCOntato = new ContatoBusiness();
negociarCOntato.ValidarCamposObrigatorios(contato_);
EmailHelper.Enviar("*****@*****.**", "*****@*****.**", "test", "MENSAGEM ERICK");
ArquivoHelper.GravarLog("Gravado com sucesso");
}
public ActionResult <ContatoModel> Update(int id, [FromBody] ContatoModel contato)
{
if (id != contato.Id)
{
return(BadRequest());
}
_repo.Update(id, contato);
return(NoContent());
}
public ContatoModel Insert(ContatoModel contato)
{
if (contato.Nome == "")
{
return(null);
}
return(_contatoRepository.Insert(contato));
}
public Guid Salvar(ContatoModel contato)
{
using (var db = new MainContextFactory().CreateDbContext(null))
{
db.Contatos.Add(contato);
db.SaveChanges();
return(contato.Id);
}
}
public void Testar_Camadas_Com_Padrao_Facade()
{
var novoContato = new ContatoModel();
novoContato.Nome = "Zeh";
novoContato.Email = "Email01";
var contatoFacade = new ContatoFacade();
contatoFacade.IniciarProcessamento(novoContato);
}
public ActionResult EditarContato(string codContato)
{
var listaContatos = lerContatos();
ContatoModel model = new ContatoModel();
model = listaContatos.Find(x => x.IdContato == Convert.ToInt64(codContato));
return(PartialView("_partialEditarContato ", model));
}
public ContatoModel Post([FromBody] ContatoModel contato)
{
try
{
return(ContatoService.Post(contato));
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> Deletar(ContatoModel obj, int?id)
{
ViewBag.ListarContatos = await Task.Run(() => obj.ListarContatos(id));
if (obj.mensagem != null)
{
return(await Task.Run(() => RedirectToAction("Index", "Home")));
}
return(View());
}
public ContatoModel GetContato(int id)
{
ContatoModel query = null;
using (var context = new ListaTelefonicaContext())
{
query = context.Contatos.Include("operadora").SingleOrDefault(c => c.Id == id);
}
return(query);
}
public void Put(int contatoId, [FromBody] ContatoModel contato)
{
try
{
ContatoService.Put(contatoId, contato);
}
catch (Exception)
{
throw;
}
}
public IHttpActionResult GetContatoModel(int id)
{
ContatoModel contatoModel = db.Contatos.Find(id);
if (contatoModel == null)
{
return(NotFound());
}
return(Ok(contatoModel));
}
public ActionResult <ContatoModel> PostContatoModel(ContatoModel contatoModel)
{
var response = _contatoService.Insert(contatoModel);
if (response == null)
{
return(BadRequest());
}
return(CreatedAtAction("GetContatoModel", new { id = contatoModel.Codigo }, contatoModel));
}
public IHttpActionResult PostContatoModel(ContatoModel contatoModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Contatos.Add(contatoModel);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = contatoModel.Id }, contatoModel));
}
//Temos que validar algumas validações da classe de contato
public void ValidarCamposObrigatorios(ContatoModel contato_)
{
if (string.IsNullOrWhiteSpace(contato_.Nome))
{
throw new ApplicationException("Informe o nome!");
}
if (string.IsNullOrWhiteSpace(contato_.Email))
{
throw new ApplicationException("Informe o e-mail!");
}
}
public ActionResult Create(FormCollection form)
{
Contato contato = new Contato();
contato.Nome = form["Nome"];
contato.Email = form["Email"];
using (ContatoModel model = new ContatoModel()){
model.Create(contato);
return(RedirectToAction("Index"));
}
}
public static TB_CONTATO ToEntity(ContatoModel model)
{
return new TB_CONTATO
{
ID = model.Id,
DS_EMAIL = model.Email,
DS_TELEFONE = model.Telefone,
DS_NASCIMENTO = model.DataNascimento,
NM_CONTATO = model.Nome,
ID_SEXO = model.Sexo.Id,
};
}
//temos que validar algumas informacoes da classe de contato
public void ValidarCamposObrigatorios(ContatoModel contato_)
{
if (string.IsNullOrWhiteSpace(contato_.Nome))
{
throw new ApplicationException("Informe o nome");
}
if (string.IsNullOrWhiteSpace(contato_.Email))
{
throw new ApplicationException("Informe o email");
}
}
public void Testar_Camadas_Sem_Padrao_Facade()
{
//PASSO 1 - Armazenar os dados
var novoContato = new ContatoModel();
novoContato.Nome = "Zeh";
novoContato.Email = "Email01";
//PASSO 2 - Validação dos dados
var negocioContato = new ContatoBusiness();
negocioContato.ValidarCamposObrigatorios(novoContato);
//PASSO 3 - Enviar o email
EmailHelper.Enviar("*****@*****.**", "*****@*****.**", "Sem facade", "Sem facade");
//PASSO 4 - Gravar o log
ArquivoHelper.GravarLog("Gravado com sucesso");
}