public AlterarLoginSenha(Modelo.Usuario usu)
 {
     InitializeComponent();
     SessionUser.nome = usu.Nome;
     Login_Usuario.Text = usu.Login;
     Senha_Usuario.Text = usu.Senha;
 }

 public void GetDisplayValues()
 {
     var list = new Marca().GetDisplayValues();
     list = new Modelo().GetDisplayValues();
     list = new AnoFabricacao().GetDisplayValues();
     WriteLine("Count = {0}", list.Values.Count);
 }

        public static IEnumerable<Modelo.Cliente.ModeloDependenteCliente> ListarDependenteCliente(Modelo.Cliente.ModeloCliente cliente, Func<Modelo.Cliente.ModeloDependenteCliente> criacaoDependenteCliente)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(Constantes.Procedures.Cliente.Dependente.ListarDependenteCliente,
                    new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Dependente.IdCliente, cliente.Id)
                    );

                dynamic dados = objeto as dynamic;
                while (objeto.Reader.Read())
                {
                    Modelo.Cliente.ModeloDependenteCliente DependenteCliente = criacaoDependenteCliente();
                    DependenteCliente.Id = @dados.idClienteDependente;
                    DependenteCliente.Cliente = cliente;
                    DependenteCliente.GrauParentesco = Modelo.Comum.GrausParentesco.Lista.FirstOrDefault((g) => g.Id == @dados.parentesco);
                    DependenteCliente.Nome = @dados.nomeDependente;
                    DependenteCliente.IndCadastro = Convert.ToBoolean(@dados.indCadastro);
                    DependenteCliente.Observacao = @dados.observacao;
                    DependenteCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
                    yield return DependenteCliente;
                }
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }
        }

 public static void InserirContatoCliente(Modelo.Cliente.ModeloContatoCliente contatoCliente)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.Cliente.Contato.InserirContatoCliente,
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Contato.IdCliente, contatoCliente.Cliente.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Contato.TipoContato, contatoCliente.TipoContato),
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Contato.TextoContato, contatoCliente.Contato),
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Contato.Observacao, contatoCliente.Observacao)
         );
         dynamic dados = objeto as dynamic;
         objeto.Reader.Read();
         contatoCliente.Id = (int?)@dados.idContatoCliente;
         contatoCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

        /// <summary>Método que representa la llamada al procedure 'Documento_Cab_Actualizar'</summary>
        public int Actualizar(Modelo.Documento_Cab Item)
        {
            try
            {
                using (SqlConnection conexion = new SqlConnection(cadenaConexion))
                {
                    conexion.Open();
                    SqlCommand cmd = new SqlCommand("Documento_Cab_Actualizar @ccosto,@doc,@numero,@idPersona,@total,@usrMod,@fechaMod,@horaMod,@idEstado", conexion);
                    cmd.CommandType = CommandType.Text;

                    cmd.Parameters.AddWithValue("@ccosto", Item.ccosto);
                    cmd.Parameters.AddWithValue("@doc", Item.doc);
                    cmd.Parameters.AddWithValue("@numero", Item.numero);
                    cmd.Parameters.AddWithValue("@idPersona", Item.idPersona);
                    cmd.Parameters.AddWithValue("@total", Item.total);
                    cmd.Parameters.AddWithValue("@usrMod", Item.usrMod);
                    cmd.Parameters.AddWithValue("@fechaMod", Item.fechaMod);
                    cmd.Parameters.AddWithValue("@horaMod", Item.horaMod);
                    cmd.Parameters.AddWithValue("@idEstado", Item.idEstado);

                    int NumFila = cmd.ExecuteNonQuery();

                    return NumFila;
                }
            }
            catch (System.Exception)
            {
                throw;
            }
        }

 public static void InserirGrupoDiferencialCliente(Modelo.Cliente.ModeloGrupoDiferencialCliente grupoDiferencialCliente)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.Cliente.GrupoDiferencial.InserirGrupoDiferencialCliente,
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.GrupoDiferencial.IdCliente, grupoDiferencialCliente.Cliente.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.GrupoDiferencial.IdGrupoDiferencial, grupoDiferencialCliente.GrupoDiferencial.Id)
         );
         dynamic dados = objeto as dynamic;
         objeto.Reader.Read();
         grupoDiferencialCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

 public static void InserirRecorteProcesso(Modelo.Processo.ModeloRecorteProcesso recorteProcesso)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.Processo.Recorte.InserirRecorteProcesso,
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Recorte.IdProcesso, recorteProcesso.Processo.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Recorte.IdUsuario, recorteProcesso.UsuarioInclusao.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Recorte.TextoRecorte, recorteProcesso.TextoRecorte)
         );
         dynamic dados = objeto as dynamic;
         objeto.Reader.Read();
         recorteProcesso.DataInclusao = @dados.dataInclusao;
         recorteProcesso.OrigemDados = Modelo.Comum.OrigemDados.Banco;
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

 public static void AlterarTipoAcao(Modelo.Acao.ModeloTipoAcao tipoAcao)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.TipoAcao.AlterarTipoAcao,
             new KeyValuePair<string, object>(Constantes.Parametros.TipoAcao.IdAcao, tipoAcao.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.TipoAcao.Descricao, tipoAcao.Descricao)
         );
         tipoAcao.OrigemDados = Modelo.Comum.OrigemDados.Banco;
         tipoAcao.Sujo = false;
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

        public static void InserirTipoAcao(Modelo.Acao.ModeloTipoAcao tipoAcao)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(
                    Constantes.Procedures.TipoAcao.InserirTipoAcao,
                    new KeyValuePair<string, object>(Constantes.Parametros.TipoAcao.Descricao, tipoAcao.Descricao)
                );

                dynamic dados = objeto as dynamic;
                objeto.Reader.Read();
                tipoAcao.Id = (int?)@dados.idAcao;
                tipoAcao.OrigemDados = Modelo.Comum.OrigemDados.Banco;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }
        }

        public static IEnumerable<Modelo.Cliente.ModeloProcessoCliente> ListarClienteProcesso(Modelo.Processo.ModeloProcesso processo, Func<Modelo.Cliente.ModeloProcessoCliente> criacaoProcessoCliente)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(Constantes.Procedures.Cliente.Processo.ListarProcessoCliente,
                    new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Processo.IdProcesso, processo.Id),
                    new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Processo.IdCliente, null)
                    );

                dynamic dados = objeto as dynamic;
                while (objeto.Reader.Read())
                {
                    Modelo.Cliente.ModeloProcessoCliente processoCliente = criacaoProcessoCliente();
                    processoCliente.Cliente.Id = @dados.idCliente;
                    AcessoCliente.ObterCliente(processoCliente.Cliente);
                    processoCliente.Processo = processo;
                    processoCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
                    yield return processoCliente;
                }
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }
        }

 public static bool ObterClienteProcesso(Modelo.Cliente.ModeloProcessoCliente processoCliente)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(Constantes.Procedures.Cliente.Processo.ListarProcessoCliente,
                             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Processo.IdProcesso, processoCliente.Processo.Id),
                             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Processo.IdCliente, processoCliente.Cliente.Id)
                             );
         if (objeto.Reader.Read())
         {
             processoCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
             return true;
         }
         else {
             return false;
         }
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

 public void Insert(Modelo.Clientes cliente)
 {
     SqlConnection conexao = new SqlConnection(strCon);
     string sql = "Insert into Clientes values (@idCidade, @nome, @telefone, @celular, @endereco, @cpf, @email)";
     SqlCommand cmd = new SqlCommand(sql, conexao);
     cmd.Parameters.AddWithValue("@idCidade", cliente.idCidade);
     cmd.Parameters.AddWithValue("@nome", cliente.nome);
     cmd.Parameters.AddWithValue("@telefone", cliente.telefone);
     cmd.Parameters.AddWithValue("@celular", cliente.celular);
     cmd.Parameters.AddWithValue("@endereco", cliente.endereco);
     cmd.Parameters.AddWithValue("@cpf", cliente.cpf);
     cmd.Parameters.AddWithValue("@email", cliente.email);
     conexao.Open();
     try
     {
         cmd.ExecuteNonQuery();
     }
     catch
     {
         Console.WriteLine("Deu erro na inserção de Cliente...");
     }
     finally
     {
         conexao.Close();
     }
 }

 public Servidor()
 {
     Modelo = new Modelo();
     Especificacion = new EspServidor();
     TipoServidor = new TipoServidor();
     Estatus = new Estatus();
 }

        public static void InserirAdvogado(Modelo.Advogado.ModeloAdvogado advogado)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(
                    Constantes.Procedures.Advogado.InserirAdvogado,
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.OAB, advogado.Oab),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.CPF, advogado.Cpf),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.RG, advogado.Rg),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.Nome, advogado.Nome),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.IndEstagiario, advogado.IndicadorEstagiario),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.EstadoCivil, advogado.EstadoCivil),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.Naturalidade, advogado.Naturalidade),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.Nacionalidade, advogado.Nacionalidade),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.Sexo, advogado.Sexo)
                );

                dynamic dados = objeto as dynamic;
                objeto.Reader.Read();
                advogado.Id = (int?)@dados.idAdvogado;
                advogado.OrigemDados = OrigemDados.Banco;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }
        }

        public void CadastrarItensVenda(Modelo.ItensVenda item)
        {
            FactoryConnection conn = new FactoryConnection();
            String query = "";
            try
            {
                if (item.IdProduto == 0)
                {
                    query = "insert into VendaProdutoServico (IdVenda, IdServico) values" +
                     "('" + item.IdVenda + "', '" + item.IdServico + "')";
                }
                if (item.IdServico == 0)
                {
                    query = "insert into VendaProdutoServico (IdVenda,  IdProduto) values" +
                        "('" + item.IdVenda + "', '" + item.IdProduto + "')";
                }

                SqlCommand comand = new SqlCommand(query, conn.AbrirConnexao());
                SqlDataReader reader = comand.ExecuteReader();

            }
            catch (Exception e)
            {
                MessageBox.Show("Não foi possível conectar-se ao banco de dados!");
            }
            finally
            {
                conn.FecharConnecxao();
            }
        }

 public static void AlterarGrupoDiferencial(Modelo.GrupoDiferencial.ModeloGrupoDiferencial grupoDiferencial)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.GrupoDiferencial.AlterarGrupoDiferencial,
             new KeyValuePair<string, object>(Constantes.Parametros.GrupoDiferencial.IdGrupoDiferencial, grupoDiferencial.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.GrupoDiferencial.Nome, grupoDiferencial.Nome)
         );
         grupoDiferencial.OrigemDados = Modelo.Comum.OrigemDados.Banco;
         grupoDiferencial.Sujo = false;
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

        public int CadastrarVenda(Modelo.Venda venda)
        {
            FactoryConnection conn = new FactoryConnection();
            int id = 0;
            string sSQL = @"INSERT INTO Venda
                    (Valor, DataHoje, CPFFuncionario, CPFCliente) VALUES (@Valor, @DataHoje, @CPFFuncionario, @CPFCliente)
                    SET @IdVenda = SCOPE_IDENTITY()";
            try
            {
                SqlCommand cmd = new SqlCommand(sSQL, conn.AbrirConnexao());
                cmd.Parameters.AddWithValue("@Valor", venda.ValorTotal);
                cmd.Parameters.AddWithValue("@DataHoje", DateTime.Now);
                cmd.Parameters.AddWithValue("@CPFFuncionario", venda.CPFFuncionario);
                cmd.Parameters.AddWithValue("@CPFCliente", venda.CPFCliente);
                cmd.Parameters.AddWithValue("@IdVenda", 0).Direction = System.Data.ParameterDirection.Output;

                cmd.ExecuteNonQuery();

                id = Convert.ToInt32(cmd.Parameters["@IdVenda"].Value);

            }
            catch (Exception e)
            {
                MessageBox.Show("Não foi possível conectar-se ao banco de dados!");
            }
            finally
            {
                conn.FecharConnecxao();

            }
            return id;
        }

        public void Insert(Modelo.Titulo obj)
        {
            // Cria Conexão com banco de dados
            SqlConnection conn = new SqlConnection(connectionString);
            // Abre conexão com o banco de dados
            conn.Open();
            // Cria comando SQL
            SqlCommand com = conn.CreateCommand();
            // Define comando de exclusão
            SqlCommand cmd = new SqlCommand("INSERT INTO Titulos(ISBN,titulo,autor,editora,ano,descricao,pesoEmKg,alturaEmCm,larguraEmCm,profundidadeEmCm,codigoDeBarras,numeroPaginas,acabamento,edicao,categoria_id,idioma_id,capa) VALUES (@ISBN,@titulo,@autor,@editora,@ano,@descricao,@pesoEmKg,@alturaEmCm,@larguraEmCm,@profundidadeEmCm,@codigoDeBarras,@numeroPaginas,@acabamento,@edicao,@categoria_id,@idioma_id,@capa)", conn);
            cmd.Parameters.AddWithValue("@ISBN", obj.ISBN);
            cmd.Parameters.AddWithValue("@titulo", obj.titulo);
            cmd.Parameters.AddWithValue("@autor", obj.autor);
            cmd.Parameters.AddWithValue("@editora", obj.editora);
            cmd.Parameters.AddWithValue("@ano", obj.ano);
            cmd.Parameters.AddWithValue("@descricao", obj.descricao);
            cmd.Parameters.AddWithValue("@pesoEmKg", obj.pesoEmKg);
            cmd.Parameters.AddWithValue("@alturaEmCm", obj.alturaEmCm);
            cmd.Parameters.AddWithValue("@larguraEmCm", obj.larguraEmCm);
            cmd.Parameters.AddWithValue("@profundidadeEmCm", obj.profundidadeEmCm);
            cmd.Parameters.AddWithValue("@codigoDeBarras", obj.codigoDeBarras);
            cmd.Parameters.AddWithValue("@numeroPaginas", obj.numeroPaginas);
            cmd.Parameters.AddWithValue("@acabamento", obj.acabamento);
            cmd.Parameters.AddWithValue("@edicao", obj.edicao);
            cmd.Parameters.AddWithValue("@categoria_id", obj.categoriaID);
            cmd.Parameters.AddWithValue("@idioma_id", obj.idiomaID);
            cmd.Parameters.AddWithValue("@capa", obj.capa);

            // Executa Comando
            cmd.ExecuteNonQuery();
        }

        //acho que não precisa disso
        /*public static bool ObterGrupoDiferencialCliente(Modelo.Cliente.ModeloGrupoDiferencialCliente grupoDiferencialCliente)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(Constantes.Procedures.Cliente.GrupoDiferencial.ObterGrupoDiferencialCliente,
                    new KeyValuePair<string, object>(Constantes.Parametros.Cliente.GrupoDiferencial.IdGrupoDiferencial, grupoDiferencialCliente.GrupoDiferencial.Id),
                    new KeyValuePair<string, object>(Constantes.Parametros.Cliente.GrupoDiferencial.IdCliente, grupoDiferencialCliente.Cliente.Id)
                    );

                dynamic dados = objeto as dynamic;
                if (objeto.Reader.Read())
                {
                    grupoDiferencialCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
                    return true;
                }
                else return false;
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }

        }*/
        public static IEnumerable<Modelo.Cliente.ModeloGrupoDiferencialCliente> ListarGrupoDiferencialCliente(Modelo.Cliente.ModeloCliente cliente, Func<Modelo.Cliente.ModeloGrupoDiferencialCliente> criacaoGrupoDiferencialCliente)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(Constantes.Procedures.Cliente.GrupoDiferencial.ListarGrupoDiferencialCliente,
                    new KeyValuePair<string, object>(Constantes.Parametros.Cliente.GrupoDiferencial.IdCliente, cliente.Id)
                    );

                dynamic dados = objeto as dynamic;
                while (objeto.Reader.Read())
                {
                    Modelo.Cliente.ModeloGrupoDiferencialCliente grupoDiferencialCliente = criacaoGrupoDiferencialCliente();
                    grupoDiferencialCliente.Cliente = cliente;
                    grupoDiferencialCliente.GrupoDiferencial.Id = @dados.idGrupoDiferencial;
                    AcessoGrupoDiferencial.ObterGrupoDiferencial(grupoDiferencialCliente.GrupoDiferencial);
                    grupoDiferencialCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
                    yield return grupoDiferencialCliente;
                }
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }
        }

 public static void AlterarProcesso(Modelo.Processo.ModeloProcesso processo)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.Processo.AlterarProcesso,
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.IdProcesso, processo.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.NumeroProcesso, processo.NumeroProcesso),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.IdTipoAcao, processo.TipoAcao.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Objetivo, processo.Objetivo),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Vara, processo.Vara),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Cabeca, processo.Cabeca.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.DataAjuizamentoAcao, processo.DataAjuizamentoAcao),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Observacao, processo.Observacao),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Reu, processo.Reu),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.NumeroOrdem, processo.NumeroOrdem),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.QuantidadeDiasAlerta, processo.QuantidadeDiasAlerta)
         );
         processo.OrigemDados = Modelo.Comum.OrigemDados.Banco;
         processo.Sujo = false;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }