public ResultValidation Alterar(TipoContato tipoContato)
{
ResultValidation returnValidation = new ResultValidation();
if (repoTipoContato.Exists(i => i.Nome.ToUpper().Trim() == tipoContato.Nome.ToUpper().Trim() &&
i.Id != tipoContato.Id))
{
returnValidation.AddMessage("Nome", "Nome já cadastrado.");
}
if (!returnValidation.Ok)
{
return(returnValidation);
}
try
{
repoTipoContato.Update(tipoContato);
context.SaveChanges();
}
catch (Exception err)
{
returnValidation.AddMessage("", err);
}
return(returnValidation);
}
protected void Page_Load(object sender, EventArgs e)
{
grdUsuarios.DataSource = Usuario.ObterUsuarios();
grdUsuarios.DataBind();
if (!this.IsPostBack)
{
ddlTipoContato1.DataSource = TipoContato.ObterTiposContato();
ddlTipoContato1.DataBind();
ddlTipoContato1.Items.Insert(0, new ListItem(""));
ddlTipoContato2.DataSource = TipoContato.ObterTiposContato();
ddlTipoContato2.DataBind();
ddlTipoContato2.Items.Insert(0, new ListItem(""));
ddlTipoContato3.DataSource = TipoContato.ObterTiposContato();
ddlTipoContato3.DataBind();
ddlTipoContato3.Items.Insert(0, new ListItem(""));
ddlTipoContato4.DataSource = TipoContato.ObterTiposContato();
ddlTipoContato4.DataBind();
ddlTipoContato4.Items.Insert(0, new ListItem(""));
ddlTipoContato5.DataSource = TipoContato.ObterTiposContato();
ddlTipoContato5.DataBind();
ddlTipoContato5.Items.Insert(0, new ListItem(""));
}
}
private void ValidarTipoContatoCadastrado(TipoContato tipoContato)
{
if (_consultador.ExisteTipoContatoCadastrado(tipoContato))
{
throw new Exception("Já existe um Tipo de Contato cadastrado com este nome!");
}
}
private void btnSalvar_Click(object sender, EventArgs e)
{
try
{
if (string.IsNullOrEmpty(txtCodigo.Text))
{
var tipoContatoFactory = new TipoContatoFactory(txtDescricao.Text, 1);
var tipoContato = tipoContatoFactory.Criar();
_tipoContatoRepository.IncluirTipoContato(tipoContato);
MessageBox.Show(Resources.Registro_incluido);
}
else
{
var tipoContato = new TipoContato
{
IdFormatado = txtCodigo.Text,
Descricao = txtDescricao.Text,
Ativo = rdAtivoSim.Checked,
DataAlteracao = DateTime.Now,
IdUsuarioAlteracao = 1
};
_tipoContatoRepository.AlterarTipoContato(tipoContato);
MessageBox.Show(Resources.Registro_alterado);
}
PreencheGrid();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public int InserirTipoContato(TipoContato tipocontato)
{
int codigoGerado = 0;
string comandoSQL = "Insert into TipoContato(Nome, Descricao) values (@Nome, @Descricao);";
MySqlConnection conexao = new MySqlConnection("Server=localhost;Database=AgendaContatos;Uid=root;Pwd=;");
MySqlCommand comando = new MySqlCommand(comandoSQL, conexao);
comando.Parameters.AddWithValue("@Nome", tipocontato.Nome);
comando.Parameters.AddWithValue("@Descricao", tipocontato.Descricao);
conexao.Open();
comando.ExecuteNonQuery();
comando = new MySqlCommand("SELECT MAX(Codigo) from TipoContato", conexao);
MySqlDataReader dr = comando.ExecuteReader();
while (dr.Read())
{
codigoGerado = Convert.ToInt32(dr[0]);
}
return(codigoGerado);
}
public ReturnAction Save(TipoContatoModel model, Guid id)
{
ReturnAction retorno = new ReturnAction();
var sit = db.TipoContato.AsNoTracking().Where(w => w.Id == model.Id);
if (sit.Any())
{
retorno.Mensagens.Add("O indexador do item já está cadastrado.");
}
else
{
var obj = new TipoContato(id, model.Nome);
if (!obj.EhValido())
{
foreach (var item in obj.Get)
{
retorno.Mensagens.Add(item.Value);
}
}
else
{
db.Entry(obj).State = EntityState.Added;
db.SaveChanges();
}
}
return(retorno);
}
public bool ExistemContatosVinculados(TipoContato TipoContato)
{
var config = _repositorio.Buscar.CriarProcedure("spExistemContatosVinculados");
config.DefinirParametro(c => c.Id).Valor(TipoContato.Id);
return(_repositorio.Buscar.Existe(config));
}
public TipoContato ConsultaTipoContato(Int32 codigo)
{
TipoContato retornoConsulta = new TipoContato();
string comandoSQL = "SELECT * FROM TipoContato where Codigo=@Codigo;";
MySqlConnection conexao = new MySqlConnection("Server=localhost;Database=AgendaContatos;Uid=root;Pwd=;"); //Ponte
MySqlCommand comando = new MySqlCommand(comandoSQL, conexao);
comando.Parameters.AddWithValue("@Codigo", codigo);
conexao.Open();
MySqlDataReader dr = comando.ExecuteReader();
while (dr.Read())
{
retornoConsulta = new TipoContato
{
Codigo = Convert.ToInt32(dr["Codigo"]),
Nome = dr["Nome"].ToString()
};
}
return(retornoConsulta);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] TipoContato tipoContato)
{
if (id != tipoContato.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tipoContato);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoContatoExists(tipoContato.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tipoContato));
}
public ActionResult DeleteConfirmed(int id)
{
TipoContato tipoContato = dao.Buscar(id);
bool valido = dao.Deletar(tipoContato);
return(RedirectToAction("Index"));
}
public bool ExisteTipoContatoCadastrado(TipoContato tipoContato)
{
var config = _repositorio.Buscar.CriarQuery()
.AdicionarCondicao(c => c.Id).Diferente(tipoContato.Id)
.AdicionarCondicao(c => c.Nome).Igual(tipoContato.Nome);
return(_repositorio.Buscar.Existe(config));
}
public ActionResult DeleteConfirmed(int id)
{
TipoContato tipoContato = db.TipoContatoSet.Find(id);
db.TipoContatoSet.Remove(tipoContato);
db.SaveChanges();
return(RedirectToAction("Index"));
}
internal static TipoContatoViewModel MapFromEntity(TipoContato tipoContato)
{
return(new TipoContatoViewModel
{
TipoContatoId = tipoContato.TipoContatoId,
Descricao = tipoContato.Descricao
});
}
public void Excluir(TipoContato tipoContato)
{
if (_consultador.ExistemContatosVinculados(tipoContato))
{
throw new Exception("Ainda existem contatos vinculados com este Tipo de Contato!");
}
_repositorio.Excluir(tipoContato);
}
internal void TipoContatoExiste(ContatoModeloNegocio contato)
{
TipoContato tipoContato = repositorioTiposContato.Where(t => t.Id == contato.TipoContato.Id).SingleOrDefault();
if (tipoContato == null)
{
throw new OrganogramaRequisicaoInvalidaException("Tipo do Contato não existe.");
}
}
public ActionResult Edit([Bind(Include = "TipoContato1,Nome")] TipoContato tipoContato)
{
if (ModelState.IsValid)
{
bool valido = dao.Editar(tipoContato);
return(RedirectToAction("Index"));
}
return(View(tipoContato));
}
//
public bool salvar(TipoContato OTipoContato)
{
if (OTipoContato.id == 0)
{
return(this.inserir(OTipoContato));
}
return(this.atualizar(OTipoContato));
}
private void NumeroDigitosValido(ContatoModeloNegocio contato)
{
TipoContato tipoContato = repositorioTiposContato.Where(t => t.Id == contato.TipoContato.Id).Single();
if (contato.Telefone.Length != tipoContato.QuantidadeDigitos)
{
throw new OrganogramaRequisicaoInvalidaException("Telefone do tipo " + tipoContato.Descricao + " devem possuir " + tipoContato.QuantidadeDigitos + " dígitos.");
}
}
//Construtor de Contato, toda vez que usar new Contato(); passar todos os paramentros - Passe um inteiro para o TipoConrato
public Contato(string descricao, TipoContato tipoContato)
{
Descricao = descricao;
TipoContato = tipoContato; //Email = 0, TelefoneFixo = 1, Celular = 2, Site = 3
if (String.IsNullOrEmpty(descricao))
{
throw new Exception("Descricao nao pode ser Nulo ou Vazio");
}
}
public ActionResult Edit([Bind(Include = "Id,nome")] TipoContato tipoContato)
{
if (ModelState.IsValid)
{
db.Entry(tipoContato).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoContato));
}
public void Deve_Formatar_ContatoValor_De_Acordo_Com_Tipo(string valor, TipoContato tipo, string valorEsperado)
{
Contato contato = new Contato
{
Valor = valor,
TipoContato = tipo
};
Assert.Equal(contato.Valor, valorEsperado);
}
public async Task <IActionResult> Create([Bind("Id,Name")] TipoContato tipoContato)
{
if (ModelState.IsValid)
{
_context.Add(tipoContato);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tipoContato));
}
public ActionResult Create([Bind(Include = "Id,nome")] TipoContato tipoContato)
{
if (ModelState.IsValid)
{
db.TipoContatoSet.Add(tipoContato);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoContato));
}
//
private bool inserir(TipoContato OTipoContato)
{
OTipoContato.id = this.proximoId();
OTipoContato.setDefaultInsertValues();
db.TipoContato.Add(OTipoContato);
db.SaveChanges();
return(OTipoContato.id > 0);
}
public void SeExistirUmTipoContatoCadastroDeveRetornarVerdadeiro()
{
var factory = new TipoContatoFactory();
var consultador = factory.CriarConsultador();
var tipoContato = new TipoContato()
{
Nome = "Telefone"
};
consultador.ExisteTipoContatoCadastrado(tipoContato)
.Should()
.BeTrue();
}
public void SeNaoExistirUmTipoContatoCadastradoDeveRetornarFalso()
{
var factory = new TipoContatoFactory();
var consultador = factory.CriarConsultador();
var tipoContato = new TipoContato()
{
Nome = "Fumaça"
};
consultador.ExisteTipoContatoCadastrado(tipoContato)
.Should()
.BeFalse();
}
// GET: TipoContatos/Edit/5
public ActionResult Edit(int id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoContato tipoContato = dao.Buscar(id);
if (tipoContato == null)
{
return(HttpNotFound());
}
return(View(tipoContato));
}
// GET: TipoContatoes/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoContato tipoContato = db.TipoContatoSet.Find(id);
if (tipoContato == null)
{
return(HttpNotFound());
}
return(View(tipoContato));
}
public void AlterarTipoContato(TipoContato tipoContato)
{
if (!modelState.IsValid)
{
return;
}
tipoContato.DataCadastro = DateTime.Now;
tipoContato.IdUsuarioCadastro = ((UsuarioBackOffice)HttpContext.Current.Session["user"]).Id;
ResultValidation retorno = serviceTipoContato.Alterar(tipoContato);
PreencherModelState(retorno);
}
public void SeCadastrarUmTipoContatoNaoDeveGerarErro()
{
var factory = new TipoContatoFactory();
var manutencao = factory.CriarManutencao();
var tipoContato = new TipoContato()
{
Nome = "Fumaça"
};
Action cadastro = () => manutencao.Cadastrar(tipoContato);
cadastro
.ShouldNotThrow();
}
