示例#1
0
 public IList <Perfil> ObterPerfilTodos()
 {
     using (BMPerfil perfilBM = new BMPerfil())
     {
         return(perfilBM.ObterTodos().OrderBy(n => n.Nome).ToList());
     }
 }
示例#2
0
        public void PublicarNotificacao(string link, string texto, DateTime?data, int[] ufs, int[] niveis, int[] perfis)
        {
            var        ufBm  = new BMUf();
            IList <Uf> lstUf = ufs.Select(uf => ufBm.ObterPorId(uf)).ToList();

            var nivelBm = new BMNivelOcupacional();
            IList <NivelOcupacional> lstNivel = niveis.Select(nivel => nivelBm.ObterPorID(nivel)).ToList();

            var            perfilBm  = new BMPerfil();
            IList <Perfil> lstPerfil = perfis.Select(perfil => perfilBm.ObterPorId(perfil)).ToList();


            var usuarios = new BMUsuario().ObterPorUfsNiveisPerfis(lstUf, lstNivel, lstPerfil);


            var notificacaoBm = new BMNotificacao();

            foreach (var u in usuarios)
            {
                notificacaoBm.Salvar(new Notificacao
                {
                    DataGeracao      = DateTime.Now,
                    Link             = link,
                    DataNotificacao  = data,
                    TextoNotificacao = texto,
                    Usuario          = new BMUsuario().ObterPorId(u.ID)
                });
            }
        }
 public IList <Perfil> ObterPerfilTodos()
 {
     using (BMPerfil bmPerfil = new BMPerfil())
     {
         return(bmPerfil.ObterTodos());
     }
 }
示例#4
0
 public void ExcluirPerfil(DTO.Dominio.DTOPerfil pPerfil, string p)
 {
     perfilBM = new BMPerfil();
     perfilBM.Excluir(new Perfil()
     {
         ID = pPerfil.ID
     });
 }
示例#5
0
 public void IncluirPerfil(DTO.Dominio.DTOPerfil pPerfil, string UsuarioAlteracao)
 {
     perfilBM = new BMPerfil();
     perfilBM.Salvar(new Perfil()
     {
         Nome = pPerfil.Nome
     });
 }
示例#6
0
        public IList <DTOPerfil> ListarPerfil()
        {
            perfilBM = new BMPerfil();
            IList <DTOPerfil> lstResut = null;

            try
            {
                lstResut = new List <DTOPerfil>();

                foreach (Perfil pf in perfilBM.ObterTodos())
                {
                    DTOPerfil pfdto = new DTOPerfil();
                    CommonHelper.SincronizarDominioParaDTO(pf, pfdto);
                    lstResut.Add(pfdto);
                }
            }
            catch (Exception ex)
            {
                ErroUtil.Instancia.TratarErro(ex);
            }

            return(lstResut);
        }
示例#7
0
 public ManterPerfil()
     : base()
 {
     bmPerfil = new BMPerfil();
 }
 public Perfil ObterPerfilPorID(int pId)
 {
     using (BMPerfil bm = new BMPerfil()) { return(bm.ObterPorId(pId)); }
 }
 public IList <Perfil> ObterPerfilsTodos()
 {
     using (BMPerfil pfBM = new BMPerfil()) { return(pfBM.ObterTodos()); }
 }
示例#10
0
        public IList <Perfil> ObterPerfis()
        {
            var bmPerfil = new BMPerfil();

            return(bmPerfil.ObterTodos());
        }
示例#11
0
        public void PublicarEmail(EmailEnvio emailEnvio, string assunto, string texto,
                                  List <Tuple <Dictionary <string, string>, int> > hashTags, int[] ufs, int[] statusSelecionados,
                                  int[] niveisOcupacionais, int[] perfis, Turma turma = null, int[] usuarios = null)
        {
            var lstUf = new List <Uf>();
            var ufBm  = new BMUf();

            if (ufs != null)
            {
                lstUf.AddRange(ufs.Select(uf => ufBm.ObterPorId(uf)));
            }

            var statusBm  = new BMStatusMatricula();
            var lstStatus = statusSelecionados
                            .Where(status => statusBm.ObterPorId(status) != null)
                            .Select(status => statusBm.ObterPorId(status)).ToList();

            var lstNivel = new List <NivelOcupacional>();
            var nivelBm  = new BMNivelOcupacional();

            if (niveisOcupacionais != null)
            {
                lstNivel.AddRange(niveisOcupacionais.Select(nivel => nivelBm.ObterPorID(nivel)));
            }

            var lstPerfil = new List <Perfil>();
            var perfilBm  = new BMPerfil();

            if (perfis != null)
            {
                lstPerfil.AddRange(perfis.Select(perfil => perfilBm.ObterPorId(perfil)));
            }

            var lstUsuariosIds = new List <int>();

            usuarioBM = new BMUsuario();

            // Caso tenha algum filtro selecionado recupera os usuários filtrados
            if (ufs.Any() || lstStatus.Any() || lstNivel.Any() || lstPerfil.Any() || turma != null)
            {
                //var usuariosFiltrados = usuarioBM.ObterUsuariosParaEnvioEmail(lstUf, lstStatus, lstNivel, lstPerfil, turma);

                var statusIds = lstStatus.Select(x => x.ID).ToList();
                var niveisIds = lstNivel.Select(x => x.ID).ToList();
                var perfisIds = lstPerfil.Select(x => x.ID).ToList();

                var usuariosFiltradosIds = new ManterUsuario().ObterTodosIQueryable()
                                           .Join(new BMUf().ObterTodosIQueryable(), u => u.UF.ID, uf => uf.ID,
                                                 (usuario, uf) => new { usuario, uf })
                                           .Join(new ManterUsuarioPerfil().ObterTodosIQueryable(), join => join.usuario.ID,
                                                 usuarioPerfil => usuarioPerfil.Usuario.ID, (lastJoin, usuarioPerfil) =>
                                                 new
                {
                    lastJoin.usuario,
                    lastJoin.uf,
                    usuarioPerfil
                })
                                           .Join(new ManterMatriculaOferta().ObterTodosIQueryable(), join => join.usuario.ID,
                                                 matricula => matricula.Usuario.ID,
                                                 (lastJoin, matriculaOferta) =>
                                                 new
                {
                    lastJoin.usuario,
                    lastJoin.uf,
                    lastJoin.usuarioPerfil,
                    matriculaOferta
                })
                                           .Join(new ManterMatriculaTurma().ObterTodosIQueryable(), join => join.matriculaOferta.ID,
                                                 matricula => matricula.MatriculaOferta.ID,
                                                 (lastJoin, matriculaTurma) =>
                                                 new
                {
                    lastJoin.usuario,
                    lastJoin.uf,
                    lastJoin.usuarioPerfil,
                    lastJoin.matriculaOferta,
                    matriculaTurma
                })
                                           .Where(x =>
                                                  (!ufs.Any() || ufs.Contains(x.uf.ID)) &&
                                                  (!statusIds.Any() || statusIds.Contains((int)x.matriculaOferta.StatusMatricula)) &&
                                                  (!niveisIds.Any() || niveisIds.Contains(x.usuario.NivelOcupacional.ID)) &&
                                                  (!perfisIds.Any() || perfisIds.Contains(x.usuarioPerfil.Perfil.ID)) &&
                                                  (turma == null || x.matriculaTurma.Turma.ID == turma.ID))
                                           .Select(x => new
                {
                    x.usuario.ID
                })
                                           .Distinct()
                                           .ToList()
                                           .Select(x => x.ID)
                                           .ToList();

                lstUsuariosIds.AddRange(usuariosFiltradosIds);
            }

            // Adiciona usuários avulsos nos filtros gerais
            if (usuarios != null && usuarios.Any())
            {
                var lstUsuarioSelecionados = usuarios.Select(usuario => usuarioBM.ObterPorId(usuario)).Where(x => !lstUsuariosIds.Contains(x.ID));

                lstUsuariosIds.AddRange(lstUsuarioSelecionados.Where(u => u.Ativo).Select(x => x.ID));
            }

            var cpfLogado = usuarioBM.ObterUsuarioLogado().CPF;

            GerarEmailBaseEmail(lstUsuariosIds, assunto, texto, hashTags, cpfLogado, emailEnvio);
        }