/// <summary>
        /// Exclui uma lista de endereços
        /// </summary>
        /// <param name="listaDeIdentificadores">A lista de identificadores.</param>
        /// <returns></returns>
        public bool ExcluaEnderecos(List <int> listaDeIdentificadores)
        {
            UtilBD.LimpeParametros();
            UtilBD.AdicionarParametro("@IDENDERECO", SqlDbType.Int, listaDeIdentificadores);

            var sql = ConstantesBD.SQL_EXCLUA_LISTA;

            return(UtilBD.ExecuteAtualizacao(sql) > 0);
        }
        /// <summary>
        /// Metodo responsavel por alterar um Dependente.
        /// </summary>
        /// <param name="dependente">Objeto do tipo Dependente a ser alterado</param>
        public void Alterar(Dependente dependente)
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();

            try
            {
                SqlCommand comando = new SqlCommand(QUERY_UPDATE, conexao);
                comando.Parameters.AddWithValue("@DataNascimento", dependente.DataNascimento);
                comando.Parameters.AddWithValue("@Nome", dependente.Nome);
                comando.Parameters.AddWithValue("@Parentesco", dependente.Parentesco);
                comando.Parameters.AddWithValue("@Religiao", dependente.Religiao);
                comando.Parameters.AddWithValue("@Status", (int)dependente.Status);
                comando.Parameters.AddWithValue("@PercentualCobertura", dependente.PercentualCobertura);
                comando.Parameters.AddWithValue("@TitularId", dependente.TitularId);
                comando.Parameters.AddWithValue("@Id", dependente.Id);
                conexao.Open();
                int regitrosAfetados = comando.ExecuteNonQuery();
            }
            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
        /// <summary>
        /// Metodo responsavel por retornar uma Cidade com o Id informado.
        /// </summary>
        /// <param name="Id">Id da Cidade a ser pesquisada.</param>
        /// <returns>Objeto do tipo Cidade com o Id informado</returns>
        public Cidade Consultar(int id)
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();
            Cidade        cidade  = null;

            try
            {
                SqlCommand    comando = new SqlCommand(QUERY_SELECT_CIDADE_ESTADO, conexao);
                SqlDataReader resultado;
                comando.Parameters.AddWithValue("@Id", id);
                conexao.Open();

                resultado = comando.ExecuteReader();
                resultado.Read();
                if (resultado.HasRows)
                {
                    cidade = this.CriarCidade(resultado);
                }

                resultado.Close();
            }

            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }

            return(cidade);
        }
        /// <summary>
        /// Metodo responsavel por alterar um Contrato.
        /// </summary>
        /// <param name="contrato">Objeto do tipo Contrato a ser alterado</param>
        public void Alterar(Contrato contrato)
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();

            try
            {
                SqlCommand comando = new SqlCommand(QUERY_UPDATE, conexao);
                comando.Parameters.AddWithValue("@Id", contrato.Id);
                comando.Parameters.AddWithValue("@DataInicio", contrato.DataInicio);
                comando.Parameters.AddWithValue("@PlanoId", contrato.Plano.Id);
                comando.Parameters.AddWithValue("@Status", (int)contrato.Status);
                comando.Parameters.AddWithValue("@TitularId", contrato.TitularId);
                conexao.Open();
                int regitrosAfetados = comando.ExecuteNonQuery();
            }
            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
        /// <summary>
        /// Metodo responsavel por inserir um HistoricoDependente.
        /// </summary>
        /// <param name="historicoDependente">Objeto do tipo HistoricoDependente a ser inserido</param>
        /// <returns>retorna o HistoricoDependente inserido.</returns>
        public HistoricoDependente Inserir(HistoricoDependente historicoDependente)
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();

            try
            {
                SqlCommand comando = new SqlCommand(QUERY_INSERT, conexao);
                comando.Parameters.AddWithValue("@DataNascimento", historicoDependente.DependenteHistorico.DataNascimento);
                comando.Parameters.AddWithValue("@Nome", historicoDependente.DependenteHistorico.Nome);
                comando.Parameters.AddWithValue("@Parentesco", historicoDependente.DependenteHistorico.Parentesco);
                comando.Parameters.AddWithValue("@Religiao", historicoDependente.DependenteHistorico.Religiao);
                comando.Parameters.AddWithValue("@Status", (int)historicoDependente.DependenteHistorico.Status);
                comando.Parameters.AddWithValue("@PercentualCobertura", historicoDependente.DependenteHistorico.PercentualCobertura);
                comando.Parameters.AddWithValue("@TitularId", historicoDependente.DependenteHistorico.TitularId);
                comando.Parameters.AddWithValue("@DependenteId", historicoDependente.Dependente.Id);
                comando.Parameters.AddWithValue("@DataAlteracao", historicoDependente.DataAlteracao);
                comando.Parameters.AddWithValue("@UsuarioId", historicoDependente.Usuario.Id);
                comando.Parameters.AddWithValue("@Descricao", historicoDependente.Descricao);
                conexao.Open();
                int regitrosAfetados = comando.ExecuteNonQuery();
                // historicoDependente.DependenteHistorico.Id = this.ObterMaximoId();
            }
            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
            return(historicoDependente);
        }
        //private static String QUERY_SELECT_CODIGO_LOCALIDADE = "SELECT * FROM DEPARTAMENTO_LOCALIDADE WHERE  COD_LOCALIDADE = ?codLocalidade";

        #endregion

        #region IRepositorioDepartamento - Tabela DEPARTAMENTO

        public void InserirDepartamento(ClassesBasicas.Departamento departamento)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            try
            {
                MySqlCommand comando = new MySqlCommand(QUERY_INSERT, conexao);
                comando.Parameters.AddWithValue("?nomeDepartamento", departamento.Nome);

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }
                int regitrosAfetados = comando.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
        /// <summary>
        /// Metodo responsavel por consultar um HistoricoTitular.
        /// </summary>
        /// <param name="id">Id a ser consultado.</param>
        /// <returns>retorna um HistoricoTitular com o Id informado.</returns>
        public HistoricoTitular Consultar(int id)
        {
            UtilBD           banco            = new UtilBD();
            SqlConnection    conexao          = banco.ObterConexao();
            HistoricoTitular historicoTitular = null;

            try
            {
                SqlCommand    comando = new SqlCommand(QUERY_SELECT_ID, conexao);
                SqlDataReader resultado;
                comando.Parameters.AddWithValue("@Id", id);
                conexao.Open();

                resultado = comando.ExecuteReader();
                resultado.Read();
                if (resultado.HasRows)
                {
                    historicoTitular = this.CriarHistoricoTitular(resultado);
                }

                resultado.Close();
            }

            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }

            return(historicoTitular);
        }
Exemple #8
0
        /// <summary>
        /// Metodo responsavel por consultar um Usuario pelo seu Login.
        /// </summary>
        /// <param name="login">Login a ser pesquisado.</param>
        /// <returns>Objeto do tipo Usuario.</returns>
        public Usuario Consultar(string login)
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();
            Usuario       usuario = null;

            try
            {
                SqlCommand    comando = new SqlCommand(QUERY_SELECT_LOGIN, conexao);
                SqlDataReader resultado;
                comando.Parameters.AddWithValue("@Login", login);
                conexao.Open();

                resultado = comando.ExecuteReader();

                resultado.Read();
                if (resultado.HasRows)
                {
                    usuario = this.CriarUsuario(resultado);
                }

                resultado.Close();
            }

            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }

            return(usuario);
        }
Exemple #9
0
        public void AlterarAlocar(Empregado empregado)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            try
            {
                MySqlCommand comando = new MySqlCommand(QUERY_UPDATE_ALOCAR, conexao);

                comando.Parameters.AddWithValue("?codEmpregado", empregado.Codigo);
                comando.Parameters.AddWithValue("?codDepartamento", empregado.DepartamentoAlocado.Codigo);
                comando.Parameters.AddWithValue("?dataAlocacao", empregado.DataAlocação);

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }
                int regitrosAfetados = comando.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
Exemple #10
0
        /// <summary>
        /// Metodo responsavel por inserir um Usuario.
        /// </summary>
        /// <param name="usuario">Objeto do tipo Usuario a ser inserido</param>
        /// <returns>retorna o Usuario inserido.</returns>
        public Usuario Inserir(Usuario usuario)
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();

            try
            {
                SqlCommand comando = new SqlCommand(QUERY_INSERT, conexao);
                comando.Parameters.AddWithValue("@Nome", usuario.Nome);
                comando.Parameters.AddWithValue("@Login", usuario.Login);
                comando.Parameters.AddWithValue("@Senha", usuario.Senha);
                comando.Parameters.AddWithValue("@Status", (int)usuario.Status);
                conexao.Open();
                int regitrosAfetados = comando.ExecuteNonQuery();
                usuario.Id = this.ObterMaximoId();
            }
            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
            return(usuario);
        }
Exemple #11
0
        public void AlterarProjeto(ClassesBasicas.Projeto projeto)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            try
            {
                MySqlCommand comando = new MySqlCommand(QUERY_UPDATE, conexao);

                comando.Parameters.AddWithValue("?codDepartamento", projeto.Departamento.Codigo);
                comando.Parameters.AddWithValue("?codLocalidade", projeto.Localidade.Codigo);
                comando.Parameters.AddWithValue("?nomeprojeto", projeto.Nome);
                comando.Parameters.AddWithValue("?codProjeto", projeto.Codigo);

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }
                int regitrosAfetados = comando.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
Exemple #12
0
        public void InserirEmpregadoProjeto(ClassesBasicas.Projeto projeto)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            try
            {
                for (int i = 0; i < projeto.Empregados.Count; i++)
                {
                    MySqlCommand comando = new MySqlCommand(QUERY_INSERT_EMPREGADO_PROJETO, conexao);
                    comando.Parameters.AddWithValue("?codProjeto", projeto.Codigo);
                    Empregado empregado = (Empregado)projeto.Empregados[i];
                    comando.Parameters.AddWithValue("?codEmpregado", empregado.Codigo);

                    if (conexao.State == System.Data.ConnectionState.Closed)
                    {
                        conexao.Open();
                    }
                    else
                    {
                        conexao.Close();
                        conexao.Open();
                    }
                    int regitrosAfetados = comando.ExecuteNonQuery();
                }
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
        /// <summary>
        /// Metodo responsavel por alterar uma Parcela.
        /// </summary>
        /// <param name="plano">Objeto do tipo Parcela a ser alterado</param>
        public void Alterar(Parcela parcela)
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();

            try
            {
                SqlCommand comando = new SqlCommand(QUERY_UPDATE, conexao);
                comando.Parameters.AddWithValue("@DataPagamento", parcela.DataPagamento);
                comando.Parameters.AddWithValue("@DataVencimento", parcela.DataVencimento);
                comando.Parameters.AddWithValue("@Valor", parcela.Valor);
                comando.Parameters.AddWithValue("@NumeroParcela", parcela.NumeroParcela);
                comando.Parameters.AddWithValue("@Status", (int)parcela.Status);
                comando.Parameters.AddWithValue("@ContratoId", parcela.Id);
                comando.Parameters.AddWithValue("@Id", parcela.ContratoId);
                conexao.Open();
                int regitrosAfetados = comando.ExecuteNonQuery();
            }
            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
Exemple #14
0
        public void AlterarDependente(Dependente dependente)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            try
            {
                MySqlCommand comando = new MySqlCommand(QUERY_UPDATE, conexao);
                comando.Parameters.AddWithValue("?codEmpregado", dependente.Empregado.Codigo);
                comando.Parameters.AddWithValue("?nomeDependente", dependente.Nome);
                comando.Parameters.AddWithValue("?grauParentesco", dependente.GrauParentesco);
                comando.Parameters.AddWithValue("?dataNascimento", dependente.DataNascimento);
                comando.Parameters.AddWithValue("?sexo", dependente.Sexo);
                comando.Parameters.AddWithValue("?codDependente", dependente.Codigo);

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }
                int regitrosAfetados = comando.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
        /// <summary>
        /// Metodo responsavel por consultar todos os HistoricosTitular cadastrados.
        /// </summary>
        /// <returns>retorna uma Lista com todos os HistoricosTitular cadastrados.</returns>
        public List <HistoricoTitular> Consultar()
        {
            UtilBD                  banco      = new UtilBD();
            SqlConnection           conexao    = banco.ObterConexao();
            List <HistoricoTitular> historicos = new List <HistoricoTitular>();

            try
            {
                SqlCommand    comando = new SqlCommand(QUERY_SELECT_ALL, conexao);
                SqlDataReader resultado;
                conexao.Open();

                resultado = comando.ExecuteReader();

                if (resultado.HasRows)
                {
                    while (resultado.Read())
                    {
                        historicos.Add(this.CriarHistoricoTitular(resultado));
                    }
                }
                resultado.Close();
            }

            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }

            return(historicos);
        }
        /// <summary>
        /// Devolve o numero do maior Id inserido;
        /// </summary>
        /// <returns>valor do maior id</returns>
        private int ObterMaximoId()
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();
            int           id      = 0;

            try
            {
                SqlCommand    comando = new SqlCommand(QUERY_MAX_ID, conexao);
                SqlDataReader resultado;
                conexao.Open();

                resultado = comando.ExecuteReader();
                resultado.Read();
                if (resultado.HasRows)
                {
                    if (resultado["Id"] != DBNull.Value)
                    {
                        id = Convert.ToInt32(resultado["Id"]);
                    }
                }
                resultado.Close();
            }

            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }

            return(id);
        }
Exemple #17
0
        public void InserirChefiar(Empregado empregado)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            try
            {
                MySqlCommand comando = new MySqlCommand(QUERY_INSERT_CHEFIAR, conexao);

                comando.Parameters.AddWithValue("?codEmpregado", empregado.Codigo);
                comando.Parameters.AddWithValue("?codDepartamento", empregado.DepartamentoChefiado.Codigo);
                comando.Parameters.AddWithValue("?dataInicio", empregado.DataInicio);
                comando.Parameters.AddWithValue("?dataFinal", empregado.DataFinal);

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }
                int regitrosAfetados = comando.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
Exemple #18
0
        /// <summary>
        /// Metodo responsavel por inserir um HistoricoContrato.
        /// </summary>
        /// <param name="historicoContrato">Objeto do tipo HistoricoContrato a ser inserido</param>
        /// <returns>retorna o HistoricoContrato inserido.</returns>
        public HistoricoContrato Inserir(HistoricoContrato historicoContrato)
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();

            try
            {
                SqlCommand comando = new SqlCommand(QUERY_INSERT, conexao);
                comando.Parameters.AddWithValue("@DataInicio", historicoContrato.ContratoHistorico.DataInicio);
                comando.Parameters.AddWithValue("@PlanoId", historicoContrato.ContratoHistorico.Plano.Id);
                comando.Parameters.AddWithValue("@Status", (int)historicoContrato.ContratoHistorico.Status);
                comando.Parameters.AddWithValue("@TitularId", historicoContrato.ContratoHistorico.TitularId);
                comando.Parameters.AddWithValue("@ContratoId", historicoContrato.Contrato.Id);
                comando.Parameters.AddWithValue("@DataAlteracao", historicoContrato.DataAlteracao);
                comando.Parameters.AddWithValue("@UsuarioId", historicoContrato.Usuario.Id);
                comando.Parameters.AddWithValue("@Descricao", historicoContrato.Descricao);
                conexao.Open();
                int regitrosAfetados = comando.ExecuteNonQuery();
                //historicoContrato.ContratoHistorico.Id = this.ObterMaximoId();
            }
            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
            return(historicoContrato);
        }
Exemple #19
0
        public ArrayList ConsultarPorCodigoProjeto(Projeto projeto)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            ArrayList empregados = projeto.Empregados;

            try
            {
                MySqlCommand comando = new MySqlCommand(QUERY_SELECT_CODIGO_PROJETO, conexao);

                MySqlDataReader resultado;
                comando.Parameters.AddWithValue("?codProjeto", projeto.Codigo);

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }

                resultado = comando.ExecuteReader();
                //resultado.Read();

                if (empregados == null)
                {
                    empregados = new ArrayList();
                }
                if (resultado.HasRows)
                {
                    while (resultado.Read())
                    {
                        int codigo = resultado.GetInt32("COD_EMPREGADO");
                        empregados.Add(this.repEmpregado.ConsultarPorCodigo(codigo));
                    }
                }
                else
                {
                    // throw new ObjetoNaoExistente();
                }
                resultado.Close();
            }
            catch (ObjetoNaoExistente e)
            {
                MessageBox.Show("Nenhum projeto encontrado.");
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
            return(empregados);
        }
Exemple #20
0
        public Empregado ConsultarPorCodigoEmpregadoChefiar(Empregado empregado)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            Empregado emp = empregado;

            try
            {
                MySqlCommand comando = new MySqlCommand(QUERY_SELECT_CODIGO_EMPREGADO_CHEFIAR, conexao);

                MySqlDataReader resultado;
                comando.Parameters.AddWithValue("?codEmpregado", emp.Codigo);
                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }

                resultado = comando.ExecuteReader();
                resultado.Read();

                if (resultado.HasRows)
                {
                    int          codDepartamento = resultado.GetInt32("COD_DEPARTAMENTO");
                    DateTime     dataInicio      = resultado.GetDateTime("DATA_INICIO");
                    DateTime     dataFinal       = resultado.GetDateTime("DATA_FINAL");
                    Departamento departamento    = this.repDepartamento.ConsultarPorCodigo(codDepartamento);

                    emp.DepartamentoChefiado = departamento;
                    emp.DataInicio           = dataInicio;
                    emp.DataFinal            = dataFinal;
                }
                else
                {
                    // throw new ObjetoNaoExistente();
                }
                resultado.Close();
            }
            catch (ObjetoNaoExistente e)
            {
                MessageBox.Show("Nenhum empregado encontrado.");
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }

            return(emp);
        }
Exemple #21
0
        public ArrayList ConsultarPorNome(string nomeEmpregado)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            ArrayList empregados = new ArrayList();

            try
            {
                MySqlCommand comando = new MySqlCommand(QUERY_SELECT_NOME, conexao);

                MySqlDataReader resultado;
                comando.Parameters.AddWithValue("?nomeEmpregado", "%" + nomeEmpregado + "%");

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }

                resultado = comando.ExecuteReader();
                //resultado.Read();

                if (resultado.HasRows)
                {
                    while (resultado.Read())
                    {
                        empregados.Add(this.CriarEmpregado(resultado));
                    }
                }
                else
                {
                    // throw new ObjetoNaoExistente();
                }
                resultado.Close();
            }
            catch (ObjetoNaoExistente e)
            {
                MessageBox.Show("Nenhum empregado encontrado.");
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
            return(empregados);
        }
        /// <summary>
        /// Cadastra um endereço no banco.
        /// </summary>
        /// <param name="endereco">O endereço.</param>
        /// <returns>Indicador de sucesso na inserção.</returns>
        public bool CadastreEndereco(Endereco endereco)
        {
            UtilBD.LimpeParametros();
            UtilBD.AdicionarParametro("@DESCRICAO", SqlDbType.VarChar, endereco.Descricao);
            UtilBD.AdicionarParametro("@LOGRADOURO", SqlDbType.VarChar, endereco.Logradouro);
            UtilBD.AdicionarParametro("@BAIRRO", SqlDbType.VarChar, endereco.Bairro);
            UtilBD.AdicionarParametro("@CIDADE", SqlDbType.VarChar, endereco.Cidade);

            var sql = ConstantesBD.SQL_INSIRA_ENDERECO;

            return(UtilBD.ExecuteAtualizacao(sql) > 0);
        }
Exemple #23
0
        public ArrayList ConsultarTodos()
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            ArrayList projetos = new ArrayList();

            try
            {
                MySqlCommand    comando = new MySqlCommand(QUERY_SELECT_ALL, conexao);
                MySqlDataReader resultado;

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }
                resultado = comando.ExecuteReader();
                //resultado.Read();

                if (resultado.HasRows)
                {
                    while (resultado.Read())
                    {
                        projetos.Add(this.CriarProjeto(resultado));
                    }
                }
                else
                {
                    // throw new ObjetoNaoExistente();
                }
                resultado.Close();
            }
            catch (ObjetoNaoExistente e)
            {
                MessageBox.Show("Nenhum projeto encontrado.");
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }

            return(projetos);
        }
        /// <summary>
        /// Consulta a lista de endereços do banco.
        /// </summary>
        /// <returns>Lista com as informações de endereço.</returns>
        public List <Endereco> ConsulteListaDeEnderecos()
        {
            UtilBD.LimpeParametros();

            var sql       = ConstantesBD.SQL_CONSULTE_LISTA_DE_ENDERECO;
            var dataTable = UtilBD.ExecuteConsulta(sql);

            UtilBD.Dispose();

            var listaDeEnderecos = this.ObtenhaListaDeObjetosMontados(dataTable);

            return(listaDeEnderecos);
        }
Exemple #25
0
        public Empregado ConsultarPorCodigo(int codEmpregado)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            Empregado empregado = null;

            try
            {
                MySqlCommand comando = new MySqlCommand(QUERY_SELECT_CODIGO, conexao);

                MySqlDataReader resultado;
                comando.Parameters.AddWithValue("?codEmpregado", codEmpregado);
                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }

                resultado = comando.ExecuteReader();
                resultado.Read();

                if (resultado.HasRows)
                {
                    empregado = this.CriarEmpregado(resultado);
                }
                else
                {
                    // throw new ObjetoNaoExistente();
                }
                resultado.Close();
            }
            catch (ObjetoNaoExistente e)
            {
                MessageBox.Show("Nenhum empregado encontrado.");
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }

            return(empregado);
        }
        /// <summary>
        /// Consulta um endereço.
        /// </summary>
        /// <param name="identificador">O identificador do endereço.</param>
        /// <returns>As informações do endereço.</returns>
        public Endereco ConsulteEndereco(int identificador)
        {
            UtilBD.LimpeParametros();
            UtilBD.AdicionarParametro("@IDENDERECO", SqlDbType.Int, identificador);

            var sql = ConstantesBD.SQL_CONSULTE_ENDERECO;

            var dataTable = UtilBD.ExecuteConsulta(sql);
            var endereco  = this.ObtenhaObjetoEnderecoMontado(dataTable, 0);

            UtilBD.Dispose();

            return(endereco);
        }
        /// <summary>
        /// Metodo responsavel por retornar todos os Estados cadastrados.
        /// </summary>
        /// <returns>Lista com todos os Estados cadastrados.</returns>
        public List <Estado> Consultar()
        {
            UtilBD        banco   = new UtilBD();
            SqlConnection conexao = banco.ObterConexao();
            List <Estado> estados = new List <Estado>();

            try
            {
                SqlCommand    comando = new SqlCommand(QUERY_SELECT_ESTADO, conexao);
                SqlDataReader resultado;
                conexao.Open();

                resultado = comando.ExecuteReader();

                if (resultado.HasRows)
                {
                    while (resultado.Read())
                    {
                        Estado estado = new Estado();

                        if (resultado["Id"] != DBNull.Value)
                        {
                            estado.Id = Convert.ToInt32(resultado["Id"]);
                        }
                        if (resultado["Nome"] != DBNull.Value)
                        {
                            estado.Nome = Convert.ToString(resultado["Nome"]);
                        }
                        if (resultado["Sigla"] != DBNull.Value)
                        {
                            estado.Sigla = Convert.ToString(resultado["Sigla"]);
                        }

                        estados.Add(estado);
                    }
                }
                resultado.Close();
            }

            catch (SqlException e)
            {
                throw new ErroBanco(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }

            return(estados);
        }
Exemple #28
0
        public void InserirEmpregado(ClassesBasicas.Empregado empregado)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            try
            {
                MySqlCommand comando;

                if (empregado.Supervisor == null)
                {
                    comando = new MySqlCommand(QUERY_INSERT_1, conexao);
                }
                else
                {
                    comando = new MySqlCommand(QUERY_INSERT_2, conexao);
                    comando.Parameters.AddWithValue("?codEmpregadoSupervisor", empregado.Supervisor.Codigo);
                }

                comando.Parameters.AddWithValue("?codEndereco", empregado.Endereco.Codigo);
                comando.Parameters.AddWithValue("?nomeEmpregado", empregado.Nome);
                comando.Parameters.AddWithValue("?salario", empregado.Salario);
                comando.Parameters.AddWithValue("?cpf", empregado.Cpf);
                comando.Parameters.AddWithValue("?dataNascimento", empregado.DataNascimento);
                comando.Parameters.AddWithValue("?rg", empregado.Rg);
                comando.Parameters.AddWithValue("?sexo", empregado.Sexo);
                comando.Parameters.AddWithValue("?telefone", empregado.Telefone);

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }
                int regitrosAfetados = comando.ExecuteNonQuery();
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
        }
        public static ICollection <T> CargarDatos <T>(DataTable data) where T : class, new()
        {
            if (data == null || data.Rows == null || data.Rows.Count == 0)
            {
                return((ICollection <T>)null);
            }
            Dictionary <string, string> columnNames = UtilBD.ObtenerNombreColumnas <T>(data.Columns);
            ICollection <T>             objs        = (ICollection <T>) new Collection <T>();

            foreach (DataRow row in (InternalDataCollectionBase)data.Rows)
            {
                T obj = UtilBD.CargarDato <T>(row, columnNames);
                objs.Add(obj);
            }
            return(objs);
        }
        private ArrayList ConsultarPorDepartamento(int codDepartamento)
        {
            UtilBD          banco   = new UtilBD();
            MySqlConnection conexao = banco.ObterConexao();

            ArrayList localidades = new ArrayList();

            try
            {
                MySqlCommand    comando = new MySqlCommand(QUERY_SELECT_CODIGO_DEPARTAMENTO, conexao);
                MySqlDataReader resultado;

                comando.Parameters.AddWithValue("?codDepartamento", codDepartamento);

                if (conexao.State == System.Data.ConnectionState.Closed)
                {
                    conexao.Open();
                }
                else
                {
                    conexao.Close();
                    conexao.Open();
                }

                resultado = comando.ExecuteReader();
                //resultado.Read();

                if (resultado.HasRows)
                {
                    while (resultado.Read())
                    {
                        int codLocalidade = resultado.GetInt32("COD_LOCALIDADE");
                        localidades.Add(repLocalidade.ConsultarPorCodigo(codLocalidade));
                    }
                }
                resultado.Close();
            }
            catch (MySqlException e)
            {
                MessageBox.Show(e.Message);
            }
            finally
            {
                banco.FecharConexao(conexao);
            }
            return(localidades);
        }