public List <Entidades.GrupoTrabalhoUsuario> Consultar(Entidades.GrupoTrabalhoUsuario entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                if (entidade.Usuario != null)
                {
                    Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);
                }
                if (entidade.GrupoTrabalho != null)
                {
                    Dados.AdicionarParametros("@intIdGrupoTrabalho", entidade.GrupoTrabalho.IdGrupoTrabalho);
                }

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spGrupoTrabalhoUsuario");

                List <Entidades.GrupoTrabalhoUsuario> objRetorno = new List <Entidades.GrupoTrabalhoUsuario>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.GrupoTrabalhoUsuario objNovoGrupoTrabalhoUsuario = new Entidades.GrupoTrabalhoUsuario();

                    objNovoGrupoTrabalhoUsuario.Usuario           = new Entidades.Usuario();
                    objNovoGrupoTrabalhoUsuario.Usuario.IdUsuario = objLinha["IdUsuario"] != DBNull.Value ? Convert.ToInt32(objLinha["IdUsuario"]) : 0;
                    objNovoGrupoTrabalhoUsuario.Usuario           = new AcessoDados.Usuario().Consultar(objNovoGrupoTrabalhoUsuario.Usuario).First();

                    objNovoGrupoTrabalhoUsuario.GrupoTrabalho = new Entidades.GrupoTrabalho();
                    objNovoGrupoTrabalhoUsuario.GrupoTrabalho.IdGrupoTrabalho = objLinha["IdGrupoTrabalho"] != DBNull.Value ? Convert.ToInt32(objLinha["IdGrupoTrabalho"]) : 0;
                    objNovoGrupoTrabalhoUsuario.GrupoTrabalho = new AcessoDados.GrupoTrabalho().Consultar(objNovoGrupoTrabalhoUsuario.GrupoTrabalho).First();

                    objRetorno.Add(objNovoGrupoTrabalhoUsuario);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public List <Entidades.NoticiaImagem> Consultar(Entidades.NoticiaImagem entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                if (entidade.Noticia != null)
                {
                    Dados.AdicionarParametros("@intIdNoticia", entidade.Noticia.IdNoticia);
                }
                if (entidade.Imagem != null)
                {
                    Dados.AdicionarParametros("@intIdImagem", entidade.Imagem.IdImagem);
                }

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spNoticiaImagem");

                List <Entidades.NoticiaImagem> objRetorno = new List <Entidades.NoticiaImagem>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.NoticiaImagem objNovoNoticiaImagem = new Entidades.NoticiaImagem();

                    objNovoNoticiaImagem.Noticia           = new Entidades.Noticia();
                    objNovoNoticiaImagem.Noticia.IdNoticia = objLinha["IdNoticia"] != DBNull.Value ? Convert.ToInt32(objLinha["IdNoticia"]) : 0;
                    objNovoNoticiaImagem.Noticia           = new AcessoDados.Noticia().Consultar(objNovoNoticiaImagem.Noticia).First();

                    objNovoNoticiaImagem.Imagem          = new Entidades.Imagem();
                    objNovoNoticiaImagem.Imagem.IdImagem = objLinha["IdImagem"] != DBNull.Value ? Convert.ToInt32(objLinha["IdImagem"]) : 0;

                    objRetorno.Add(objNovoNoticiaImagem);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public List <Entidades.ImagemArquivo> Consultar(Entidades.ImagemArquivo entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdImagem", entidade.Imagem.IdImagem);
                Dados.AdicionarParametros("@binImagem", entidade.ImagemBytes);
                Dados.AdicionarParametros("@vchExtensao", entidade.Extensao);
                Dados.AdicionarParametros("@vchTamanho", entidade.Tamanho);
                Dados.AdicionarParametros("@vchFormato", entidade.Formato);

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spImagemArquivo");

                List <Entidades.ImagemArquivo> objRetorno = new List <Entidades.ImagemArquivo>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.ImagemArquivo objNovoImagemArquivo = new Entidades.ImagemArquivo();

                    objNovoImagemArquivo.Imagem          = new Entidades.Imagem();
                    objNovoImagemArquivo.Imagem.IdImagem = objLinha["IdImagem"] != DBNull.Value ? Convert.ToInt32(objLinha["IdImagem"]) : 0;
                    objNovoImagemArquivo.Imagem          = new AcessoDados.Imagem().Consultar(objNovoImagemArquivo.Imagem).First();

                    objNovoImagemArquivo.ImagemBytes = objLinha["Imagem"] != DBNull.Value ? objLinha["Imagem"] as byte[] : null;
                    objNovoImagemArquivo.Extensao    = objLinha["Extensao"] != DBNull.Value ? Convert.ToString(objLinha["Extensao"]) : "";
                    objNovoImagemArquivo.Tamanho     = objLinha["Tamanho"] != DBNull.Value ? Convert.ToString(objLinha["Tamanho"]) : "";
                    objNovoImagemArquivo.Formato     = objLinha["Formato"] != DBNull.Value ? Convert.ToString(objLinha["Formato"]) : "";

                    objRetorno.Add(objNovoImagemArquivo);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #4
0
        public List <Entidades.DiasTrabalhados> Consultar(Entidades.DiasTrabalhados entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);
                Dados.AdicionarParametros("@intIdDia", entidade.DiaSemana.IdDia);

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spDiasTrabalhados");

                List <Entidades.DiasTrabalhados> objRetorno = new List <Entidades.DiasTrabalhados>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.DiasTrabalhados objNovoDiasTrabalhados = new Entidades.DiasTrabalhados();

                    objNovoDiasTrabalhados.Usuario           = new Entidades.Usuario();
                    objNovoDiasTrabalhados.Usuario.IdUsuario = objLinha["IdUsuario"] != DBNull.Value ? Convert.ToInt32(objLinha["IdUsuario"]) : 0;
                    objNovoDiasTrabalhados.Usuario           = new AcessoDados.Usuario().Consultar(objNovoDiasTrabalhados.Usuario).First();

                    objNovoDiasTrabalhados.DiaSemana       = new Entidades.DiaSemana();
                    objNovoDiasTrabalhados.DiaSemana.IdDia = objLinha["IdDia"] != DBNull.Value ? Convert.ToInt32(objLinha["IdDia"]) : 0;
                    objNovoDiasTrabalhados.DiaSemana       = new AcessoDados.DiaSemana().Consultar(objNovoDiasTrabalhados.DiaSemana).First();

                    objRetorno.Add(objNovoDiasTrabalhados);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #5
0
        public string Inserir(Entidades.Historico entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null)
                {
                    Dados.AdicionarParametros("@vchAcao", "INSERIR");
                    Dados.AdicionarParametros("@intIdNoticia", entidade.Noticia.IdNoticia);
                    Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);
                    Dados.AdicionarParametros("@intIdStatus", entidade.StatusNoticia.IdStatus);
                    Dados.AdicionarParametros("@datDataHora", entidade.DataHora);
                    Dados.AdicionarParametros("@vchDescricao", entidade.Descricao);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spHistorico");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                    {
                        return(intResultado.ToString());
                    }
                    else
                    {
                        throw new Exception(objRetorno.ToString());
                    }
                }
                else
                {
                    return("Não foi possível executar");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #6
0
        public List <Entidades.PalavraChave> Consultar(Entidades.PalavraChave entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdPalavraChave", entidade.IdPalavraChave);
                Dados.AdicionarParametros("@intIdNoticia", entidade.Noticia.IdNoticia);
                Dados.AdicionarParametros("@vchPalavraChave", entidade.PalavraChaveTexto);

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spPalavraChave");

                List <Entidades.PalavraChave> objRetorno = new List <Entidades.PalavraChave>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.PalavraChave objNovoPalavraChave = new Entidades.PalavraChave();

                    objNovoPalavraChave.IdPalavraChave    = objLinha["IdPalavraChave"] != DBNull.Value ? Convert.ToInt32(objLinha["IdPalavraChave"]) : 0;
                    objNovoPalavraChave.Noticia           = new Entidades.Noticia();
                    objNovoPalavraChave.Noticia.IdNoticia = objLinha["IdNoticia"] != DBNull.Value ? Convert.ToInt32(objLinha["IdNoticia"]) : 0;
                    objNovoPalavraChave.PalavraChaveTexto = objLinha["PalavraChave"] != DBNull.Value ? Convert.ToString(objLinha["PalavraChave"]) : "";

                    objRetorno.Add(objNovoPalavraChave);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public string Inserir(Entidades.ImagemArquivo entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null)
                {
                    Dados.AdicionarParametros("@vchAcao", "INSERIR");
                    Dados.AdicionarParametros("@intIdImagem", entidade.Imagem.IdImagem);
                    Dados.AdicionarParametros("@binImagem", entidade.ImagemBytes);
                    Dados.AdicionarParametros("@vchExtensao", entidade.Extensao);
                    Dados.AdicionarParametros("@vchTamanho", entidade.Tamanho);
                    Dados.AdicionarParametros("@vchFormato", entidade.Formato);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spImagemArquivo");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                    {
                        return(intResultado.ToString());
                    }
                    else
                    {
                        throw new Exception(objRetorno.ToString());
                    }
                }
                else
                {
                    return("Não foi possível executar");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #8
0
        public string Alterar(Entidades.Usuario entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null && entidade.IdUsuario > 0)
                {
                    Dados.AdicionarParametros("@vchAcao", "ALTERAR");
                    Dados.AdicionarParametros("@intIdUsuario", entidade.IdUsuario);
                    Dados.AdicionarParametros("@vchLogin", entidade.Login);
                    Dados.AdicionarParametros("@vchSenha", entidade.Senha);
                    Dados.AdicionarParametros("@vchNome", entidade.Nome);
                    Dados.AdicionarParametros("@intIdTipoUsuario", entidade.TipoUsuario.IdTipoUsuario);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spUsuario");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                    {
                        return(intResultado.ToString());
                    }
                    else
                    {
                        throw new Exception(objRetorno.ToString());
                    }
                }
                else
                {
                    return("Não foi possível executar");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #9
0
        public List <Entidades.UsuarioEndereco> Consultar(Entidades.UsuarioEndereco entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spUsuarioEndereco");

                List <Entidades.UsuarioEndereco> objRetorno = new List <Entidades.UsuarioEndereco>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.UsuarioEndereco objNovoUsuarioEndereco = new Entidades.UsuarioEndereco();

                    objNovoUsuarioEndereco.Usuario           = new Entidades.Usuario();
                    objNovoUsuarioEndereco.Usuario.IdUsuario = objLinha["IdUsuario"] != DBNull.Value ? Convert.ToInt32(objLinha["IdUsuario"]) : 0;

                    objNovoUsuarioEndereco.Email    = objLinha["Email"] != DBNull.Value ? Convert.ToString(objLinha["Email"]) : null;
                    objNovoUsuarioEndereco.Telefone = objLinha["Telefone"] != DBNull.Value ? Convert.ToString(objLinha["Telefone"]) : null;

                    objRetorno.Add(objNovoUsuarioEndereco);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #10
0
        public List <Entidades.Imagem> Consultar(Entidades.Imagem entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdImagem", entidade.IdImagem);
                Dados.AdicionarParametros("@vchLegenda", entidade.Legenda);
                Dados.AdicionarParametros("@bitSelecionada", entidade.Selecionada);

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spImagem");

                List <Entidades.Imagem> objRetorno = new List <Entidades.Imagem>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.Imagem objNovoImagem = new Entidades.Imagem();

                    objNovoImagem.IdImagem       = objLinha["IdImagem"] != DBNull.Value ? Convert.ToInt32(objLinha["IdImagem"]) : 0;
                    objNovoImagem.Legenda        = objLinha["Legenda"] != DBNull.Value ? Convert.ToString(objLinha["Legenda"]) : null;
                    objNovoImagem.Selecionada    = objLinha["Selecionada"] != DBNull.Value ? Convert.ToBoolean(objLinha["Selecionada"]) : false;
                    objNovoImagem.ImagemGravacao = new AcessoDados.ImagemGravacao().Consultar(objNovoImagem).First();
                    objRetorno.Add(objNovoImagem);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #11
0
        public List <Entidades.Contratacao> Consultar(Entidades.Contratacao entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spContratacao");

                List <Entidades.Contratacao> objRetorno = new List <Entidades.Contratacao>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.Contratacao objNovoContratacao = new Entidades.Contratacao();

                    objNovoContratacao.Usuario = new Entidades.Usuario()
                    {
                        IdUsuario = objLinha["IdUsuario"] != DBNull.Value ? Convert.ToInt32(objLinha["IdUsuario"]) : 0
                    };
                    objNovoContratacao.DataHora = objLinha["DataHora"] != DBNull.Value ? Convert.ToDateTime(objLinha["DataHora"]) : (DateTime?)null;

                    objRetorno.Add(objNovoContratacao);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public List <Entidades.ImagemGravacao> Consultar(Entidades.Imagem imagem)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdImagem", imagem.IdImagem);

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spImagemGravacao");

                List <Entidades.ImagemGravacao> objRetorno = new List <Entidades.ImagemGravacao>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.ImagemGravacao objNovoImagemGravacao = new Entidades.ImagemGravacao();

                    objNovoImagemGravacao.Imagem           = new Entidades.Imagem();
                    objNovoImagemGravacao.Imagem.IdImagem  = objLinha["IdImagem"] != DBNull.Value ? Convert.ToInt32(objLinha["IdImagem"]) : 0;
                    objNovoImagemGravacao.DataHoraGravacao = objLinha["DataHoraGravacao"] != DBNull.Value ? Convert.ToDateTime(objLinha["DataHoraGravacao"]) : (DateTime?)null;
                    objNovoImagemGravacao.LocalGravacao    = objLinha["LocalGravacao"] != DBNull.Value ? Convert.ToString(objLinha["LocalGravacao"]) : "";

                    objRetorno.Add(objNovoImagemGravacao);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #13
0
        public string Excluir(Entidades.NoticiaImagem entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null && entidade.Noticia != null && entidade.Noticia.IdNoticia > 0 &&
                    entidade.Imagem != null && entidade.Imagem.IdImagem > 0)
                {
                    Dados.AdicionarParametros("@vchAcao", "DELETAR");
                    Dados.AdicionarParametros("@intIdNoticia", entidade.Noticia.IdNoticia);
                    Dados.AdicionarParametros("@intIdImagem", entidade.Imagem.IdImagem);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spNoticiaImagem");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                    {
                        return(intResultado.ToString());
                    }
                    else
                    {
                        throw new Exception(objRetorno.ToString());
                    }
                }
                else
                {
                    return("Não foi possível executar");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #14
0
        public string Alterar(Entidades.PalavraChave entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null && entidade.IdPalavraChave > 0)
                {
                    Dados.AdicionarParametros("@vchAcao", "ALTERAR");
                    Dados.AdicionarParametros("@intIdPalavraChave", entidade.IdPalavraChave);
                    Dados.AdicionarParametros("@intIdNoticia", entidade.Noticia.IdNoticia);
                    Dados.AdicionarParametros("@vchPalavraChave", entidade.PalavraChaveTexto);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spPalavraChave");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                    {
                        return(intResultado.ToString());
                    }
                    else
                    {
                        throw new Exception(objRetorno.ToString());
                    }
                }
                else
                {
                    return("Não foi possível executar");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #15
0
        public string Inserir(Entidades.UsuarioEndereco entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null)
                {
                    Dados.AdicionarParametros("@vchAcao", "INSERIR");
                    Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);
                    Dados.AdicionarParametros("@vchEmail", entidade.Email);
                    Dados.AdicionarParametros("@vchTelefone", entidade.Telefone);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spUsuarioEndereco");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                    {
                        return(intResultado.ToString());
                    }
                    else
                    {
                        throw new Exception(objRetorno.ToString());
                    }
                }
                else
                {
                    return("Não foi possível executar");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #16
0
        public string Alterar(Entidades.Imagem entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null && entidade.IdImagem > 0)
                {
                    Dados.AdicionarParametros("@vchAcao", "ALTERAR");
                    Dados.AdicionarParametros("@intIdImagem", entidade.IdImagem);
                    Dados.AdicionarParametros("@vchLegenda", entidade.Legenda);
                    Dados.AdicionarParametros("@bitSelecionada", entidade.Selecionada);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spImagem");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                    {
                        return(intResultado.ToString());
                    }
                    else
                    {
                        throw new Exception(objRetorno.ToString());
                    }
                }
                else
                {
                    return("Não foi possível executar");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public string Excluir(Entidades.GrupoTrabalhoUsuario entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null && entidade.Usuario != null && entidade.Usuario.IdUsuario > 0 &&
                    entidade.GrupoTrabalho != null && entidade.GrupoTrabalho.IdGrupoTrabalho > 0)
                {
                    Dados.AdicionarParametros("@vchAcao", "DELETAR");
                    Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);
                    Dados.AdicionarParametros("@intIdGrupoTrabalho", entidade.GrupoTrabalho.IdGrupoTrabalho);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spGrupoTrabalhoUsuario");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                    {
                        return(intResultado.ToString());
                    }
                    else
                    {
                        throw new Exception(objRetorno.ToString());
                    }
                }
                else
                {
                    return("Não foi possível executar");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #18
0
        public List <Entidades.Permissao> Consultar(Entidades.Permissao entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdPermissao", entidade.IdPermissao);
                Dados.AdicionarParametros("@vchDescricao", entidade.Descricao);

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spPermissao");

                List <Entidades.Permissao> objRetorno = new List <Entidades.Permissao>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.Permissao objNovoPermissao = new Entidades.Permissao();

                    objNovoPermissao.IdPermissao = objLinha["IdPermissao"] != DBNull.Value ? Convert.ToInt32(objLinha["IdPermissao"]) : 0;
                    objNovoPermissao.Descricao   = objLinha["Descricao"] != DBNull.Value ? Convert.ToString(objLinha["Descricao"]) : null;

                    objRetorno.Add(objNovoPermissao);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #19
0
        public string Inserir(Entidades.Noticia entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null)
                {
                    Dados.AdicionarParametros("@vchAcao", "INSERIR");
                    Dados.AdicionarParametros("@vchTitulo", entidade.Titulo);
                    Dados.AdicionarParametros("@vchConteudo", entidade.Conteudo);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spNoticia");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                    {
                        return(intResultado.ToString());
                    }
                    else
                    {
                        throw new Exception(objRetorno.ToString());
                    }
                }
                else
                {
                    return("Não foi possível executar");
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #20
0
        public List <Entidades.Historico> Consultar(Entidades.Historico entidade, List <Entidades.StatusNoticia> VariosStatusNoticia)
        {
            try
            {
                DataTable objDataTable = null;

                AcessoDados.Noticia       dadosNoticias = new AcessoDados.Noticia();
                AcessoDados.Usuario       dadosUsuarios = new AcessoDados.Usuario();
                AcessoDados.StatusNoticia dadosStatus   = new AcessoDados.StatusNoticia();

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");

                if (entidade != null)
                {
                    Dados.AdicionarParametros("@intIdHistorico", entidade.IdHistorico);
                    Dados.AdicionarParametros("@intIdNoticia", entidade.Noticia.IdNoticia);
                    Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);
                }

                string strVariosStatus = string.Empty;
                if (VariosStatusNoticia != null)
                {
                    foreach (var item in VariosStatusNoticia)
                    {
                        strVariosStatus = strVariosStatus + item.IdStatus.ToString() + ",";
                    }

                    if (!string.IsNullOrWhiteSpace(strVariosStatus))
                    {
                        strVariosStatus = strVariosStatus.Remove(strVariosStatus.Length - 1, 1);
                        Dados.AdicionarParametros("@vchVariosIdStatus", strVariosStatus);
                    }
                }

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spHistorico");

                List <Entidades.Historico> objRetorno = new List <Entidades.Historico>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.Historico objNovoHistorico = new Entidades.Historico();

                    objNovoHistorico.IdHistorico       = objLinha["IdHistorico"] != DBNull.Value ? Convert.ToInt32(objLinha["IdHistorico"]) : 0;
                    objNovoHistorico.Noticia           = new Entidades.Noticia();
                    objNovoHistorico.Noticia.IdNoticia = objLinha["IdNoticia"] != DBNull.Value ? Convert.ToInt32(objLinha["IdNoticia"]) : 0;

                    objNovoHistorico.Usuario           = new Entidades.Usuario();
                    objNovoHistorico.Usuario.IdUsuario = objLinha["IdUsuario"] != DBNull.Value ? Convert.ToInt32(objLinha["IdUsuario"]) : 0;
                    objNovoHistorico.Usuario           = dadosUsuarios.Consultar(objNovoHistorico.Usuario).First();

                    objNovoHistorico.StatusNoticia          = new Entidades.StatusNoticia();
                    objNovoHistorico.StatusNoticia.IdStatus = objLinha["IdStatus"] != DBNull.Value ? Convert.ToInt32(objLinha["IdStatus"]) : 0;
                    objNovoHistorico.StatusNoticia          = dadosStatus.Consultar(objNovoHistorico.StatusNoticia).First();

                    objNovoHistorico.DataHora  = objLinha["DataHora"] != DBNull.Value ? (DateTime?)objLinha["DataHora"] : (DateTime?)null;
                    objNovoHistorico.Descricao = objLinha["Descricao"] != DBNull.Value ? (string)objLinha["Descricao"] : (string)null;

                    objRetorno.Add(objNovoHistorico);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #21
0
        public List <Entidades.Usuario> Consultar(Entidades.Usuario entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdUsuario", entidade.IdUsuario);
                Dados.AdicionarParametros("@vchLogin", entidade.Login);
                Dados.AdicionarParametros("@vchSenha", entidade.Senha);
                Dados.AdicionarParametros("@vchNome", entidade.Nome);
                if (entidade.TipoUsuario != null && entidade.TipoUsuario.IdTipoUsuario > 0)
                {
                    Dados.AdicionarParametros("@intIdTipoUsuario", entidade.TipoUsuario.IdTipoUsuario);
                }

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spUsuario");

                List <Entidades.Usuario> objRetorno = new List <Entidades.Usuario>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.Usuario objNovoUsuario = new Entidades.Usuario();

                    objNovoUsuario.IdUsuario   = objLinha["IdUsuario"] != DBNull.Value ? Convert.ToInt32(objLinha["IdUsuario"]) : 0;
                    objNovoUsuario.Login       = objLinha["Login"] != DBNull.Value ? Convert.ToString(objLinha["Login"]) : null;
                    objNovoUsuario.Senha       = objLinha["Senha"] != DBNull.Value ? Convert.ToString(objLinha["Senha"]) : null;
                    objNovoUsuario.Nome        = objLinha["Nome"] != DBNull.Value ? Convert.ToString(objLinha["Nome"]) : null;
                    objNovoUsuario.TipoUsuario = new Entidades.TipoUsuario()
                    {
                        IdTipoUsuario = objLinha["IdTipoUsuario"] != DBNull.Value ? Convert.ToInt32(objLinha["IdTipoUsuario"]) : 0
                    };
                    objNovoUsuario.TipoUsuario = dadosTipoUsuario.Consultar(objNovoUsuario.TipoUsuario).First();

                    List <Entidades.UsuarioEndereco> enderecos = new AcessoDados.UsuarioEndereco().Consultar(new Entidades.UsuarioEndereco()
                    {
                        Usuario = objNovoUsuario, Email = null, Telefone = null
                    });

                    if (enderecos.Count > 0)
                    {
                        objNovoUsuario.UsuarioEndereco = enderecos.First();
                    }

                    List <Entidades.Contratacao> contratacoes = new AcessoDados.Contratacao().Consultar(new Entidades.Contratacao()
                    {
                        Usuario = objNovoUsuario, DataHora = null
                    });

                    if (contratacoes.Count > 0)
                    {
                        objNovoUsuario.Contratacao = contratacoes.First();
                    }

                    objRetorno.Add(objNovoUsuario);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #22
0
        public List <Entidades.Noticia> Consultar(Entidades.Noticia entidade)
        {
            try
            {
                DataTable objDataTable = null;

                Dados.LimparParametros();
                Dados.AdicionarParametros("@vchAcao", "SELECIONAR");
                Dados.AdicionarParametros("@intIdNoticia", entidade.IdNoticia);
                Dados.AdicionarParametros("@vchTitulo", entidade.Titulo);
                Dados.AdicionarParametros("@vchConteudo", entidade.Conteudo);

                objDataTable = Dados.ExecutaConsultar(System.Data.CommandType.StoredProcedure, "spNoticia");

                List <Entidades.Noticia> objRetorno = new List <Entidades.Noticia>();

                if (objDataTable.Rows.Count <= 0)
                {
                    return(objRetorno);
                }

                foreach (DataRow objLinha in objDataTable.Rows)
                {
                    Entidades.Noticia objNovaNoticia = new Entidades.Noticia();

                    objNovaNoticia.IdNoticia     = objLinha["IdNoticia"] != DBNull.Value ? Convert.ToInt32(objLinha["IdNoticia"]) : 0;
                    objNovaNoticia.Titulo        = objLinha["Titulo"] != DBNull.Value ? Convert.ToString(objLinha["Titulo"]) : null;
                    objNovaNoticia.Conteudo      = objLinha["Conteudo"] != DBNull.Value ? Convert.ToString(objLinha["Conteudo"]) : null;
                    objNovaNoticia.PalavrasChave = new AcessoDados.PalavraChave().Consultar(new Entidades.PalavraChave()
                    {
                        IdPalavraChave    = null,
                        Noticia           = objNovaNoticia,
                        PalavraChaveTexto = null
                    });

                    List <Entidades.StatusNoticia> statusConsulta = new List <Entidades.StatusNoticia>();

                    statusConsulta.Add(new Entidades.StatusNoticia()
                    {
                        IdStatus = (int)Entidades.StatusNoticiaEnum.Aprovada
                    });
                    statusConsulta.Add(new Entidades.StatusNoticia()
                    {
                        IdStatus = (int)Entidades.StatusNoticiaEnum.Criada
                    });
                    statusConsulta.Add(new Entidades.StatusNoticia()
                    {
                        IdStatus = (int)Entidades.StatusNoticiaEnum.Editada
                    });
                    statusConsulta.Add(new Entidades.StatusNoticia()
                    {
                        IdStatus = (int)Entidades.StatusNoticiaEnum.GrupoVinculado
                    });
                    statusConsulta.Add(new Entidades.StatusNoticia()
                    {
                        IdStatus = (int)Entidades.StatusNoticiaEnum.ImagensAssociadas
                    });
                    statusConsulta.Add(new Entidades.StatusNoticia()
                    {
                        IdStatus = (int)Entidades.StatusNoticiaEnum.Submetida
                    });

                    List <Entidades.Historico> historicos = new AcessoDados.Historico().Consultar(new Entidades.Historico()
                    {
                        Noticia = objNovaNoticia,
                        Usuario = new Entidades.Usuario()
                        {
                            IdUsuario = null
                        }
                    }, statusConsulta);

                    if (historicos.Count > 0)
                    {
                        var statusNoticia = (from f in historicos
                                             select f).OrderByDescending(p => p.DataHora).First().StatusNoticia;

                        objNovaNoticia.StatusNoticia = statusNoticia;
                    }


                    objRetorno.Add(objNovaNoticia);
                }

                return(objRetorno);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }