Example #1
0
        public void DuplicarObjeto(int idProcesso)
        {
            using (var transaction = repositorio.ObterTransacao())
            {
                try
                {
                    var processoOriginal = ObterPorId(idProcesso);

                    if (processoOriginal != null)
                    {
                        var processoNovo = new Processo
                        {
                            ID    = 0,
                            Nome  = processoOriginal.Nome + " - Cópia",
                            Ativo = processoOriginal.Ativo,
                            ListaProcessoResposta = null,
                            ListaEtapas           = new List <Etapa>(),
                            Uf   = processoOriginal.Uf,
                            Tipo = processoOriginal.Tipo
                        };

                        repositorio.SalvarSemCommit(processoNovo);

                        var bmEtapa = new BMEtapa();

                        foreach (var etapaOriginal in processoOriginal.ListaEtapas)
                        {
                            processoNovo.ListaEtapas.Add(bmEtapa.DuplicarObjeto(etapaOriginal, false, processoNovo));
                        }

                        // Reloopar para obter os dados relacionados.
                        foreach (var etapa in processoNovo.ListaEtapas)
                        {
                            bmEtapa.DuplicarSubDadosObjeto(etapa);
                        }

                        transaction.Commit();
                    }
                }
                catch (Exception)
                {
                    transaction.Rollback();

                    throw;
                }
            }
        }
Example #2
0
        public List <EtapaResposta> ConsultarEtapasAAnalisar(Usuario usuario, int?numero, int?demandanteId, int?processoId, int?etapaId,
                                                             List <Cargo> cargos = null, bool somenteEtapasComUmAnalista = false)
        {
            var diretores    = new List <UsuarioCargo>();
            var cargoUsuario = usuario.ObterCargo();

            if (cargoUsuario != null)
            {
                // Buscar todos os diretores, pela UF do UsuarioCargo.
                diretores = new BMUsuarioCargo().ObterPorTipoCargo(EnumTipoCargo.Diretoria).Where(x => x.Cargo.Uf.ID == cargoUsuario.Cargo.Uf.ID).ToList();
            }

            var bmProcessoResposta = new BMProcessoResposta();
            var bmEtapaResposta    = new BMEtapaResposta();
            var bmUsuario          = new BMUsuario();
            var bmEtapaPermissao   = new BMEtapaPermissao();

            var idsEtapasRespostasAbertas = bmEtapaResposta.ObterTodosIQueryable()
                                            .Where(x => x.Ativo)
                                            .Where(x => x.ProcessoResposta.Status != 0)
                                            .Where(x => x.Status == (int)enumStatusEtapaResposta.Aguardando)
                                            .Where(x => x.DataPreenchimento == null)
                                            .Select(x => x.ID).ToList();

            var idsProcessosRespostasAbertos =
                bmProcessoResposta.ObterTodosIQueryable()
                .Where(x => x.ListaEtapaResposta.AsQueryable()
                       .Select(er => new { er.ID })
                       //.Where(er => idsEtapasRespostasAbertas.Contains(er.ID)).Count() > 0
                       .Any(er => idsEtapasRespostasAbertas.Contains(er.ID))
                       );

            var ids = idsProcessosRespostasAbertos.Select(x => x.ID).AsEnumerable().Take(10000);

            var demandantes = bmUsuario.ObterTodosIQueryable()
                              .Where(x => x.ListaProcessoResposta.Any(pr => idsProcessosRespostasAbertos.Select(a => a.ID).Contains(pr.ID)))//.ToList()
                              .Select(x => new
            {
                Usuario = new Usuario
                {
                    ID                = x.ID,
                    Nome              = x.Nome,
                    Email             = x.Email,
                    CPF               = x.CPF,
                    Unidade           = x.Unidade,
                    UF                = x.UF,
                    ListaUsuarioCargo = x.ListaUsuarioCargo
                },
                Processos = x.ListaProcessoResposta.Select(y => y.ID)
                            .Where(prId => ids.Contains(prId)).ToList()
            }).ToList();

            var etapasRespostasAnalistas =
                bmEtapaResposta.ObterTodosIQueryable()
                .Where(x => ids.Contains(x.ProcessoResposta.ID))
                .Select(x => new EtapaResposta
            {
                ID = x.ID,
                ProcessoResposta = new ProcessoResposta
                {
                    ID = x.ProcessoResposta.ID
                },
                Analista = x.Analista != null
                            ? new Usuario
                {
                    ID = x.Analista.ID
                }
                            : null
            }).ToList();

            foreach (var processoResposta in idsProcessosRespostasAbertos)
            {
                processoResposta.Usuario =
                    demandantes.FirstOrDefault(d => d.Processos.Contains(processoResposta.ID))?.Usuario;

                processoResposta.ListaEtapaResposta =
                    etapasRespostasAnalistas.Where(x => x.ProcessoResposta.ID == processoResposta.ID).ToList();
            }

            var etapasRespostas = bmEtapaResposta.ObterTodosIQueryable()
                                  .Where(x => idsEtapasRespostasAbertas.Contains(x.ID))
                                  .Select(er => new EtapaResposta
            {
                ID = er.ID,
                DataPreenchimento               = er.DataPreenchimento,
                DataAlteracao                   = er.DataAlteracao,
                PrazoEncaminhamento             = er.PrazoEncaminhamento,
                PermissoesNucleoEtapaResposta   = er.PermissoesNucleoEtapaResposta,
                ListaEtapaEncaminhamentoUsuario = er.ListaEtapaEncaminhamentoUsuario
            }).ToList();

            var etapas = new BMEtapa().ObterTodosIQueryable()
                         .Where(x => x.ListaEtapaResposta.Any(er => idsEtapasRespostasAbertas.Contains(er.ID)))
                         .Select(x => new Etapa
            {
                ID = x.ID,
                PodeSerAprovadoChefeGabinete = x.PodeSerAprovadoChefeGabinete,
                Nome = x.Nome,
                ListaEtapaResposta = x.ListaEtapaResposta.Select(er => new EtapaResposta {
                    ID = er.ID
                }).ToList()
            }).ToList();

            var etapasIds = etapas.Select(x => x.ID).ToList();

            var permissoes =
                bmEtapaPermissao.ObterTodosIQueryable().Where(x => etapasIds.Contains(x.Etapa.ID))
                .Select(x => new EtapaPermissao
            {
                ID                    = x.ID,
                Notificar             = x.Notificar,
                Analisar              = x.Analisar,
                ChefeImediato         = x.ChefeImediato,
                DiretorCorrespondente = x.DiretorCorrespondente,
                GerenteAdjunto        = x.GerenteAdjunto,
                Solicitante           = x.Solicitante,
                Etapa                 = new Etapa
                {
                    ID = x.Etapa.ID
                }
            })
                .ToList();

            var idsPermissoes = permissoes.Select(x => x.ID).ToList();

            // Quebra a lista de permissões para não supera o limite do LINQ de 2100 registros em um IN
            var idPremissoesGroupList = splitList(idsPermissoes, 2000);

            foreach (var idPremissoesGroup in idPremissoesGroupList)
            {
                var usuariosPermissoes = bmUsuario.ObterTodosIQueryable()
                                         .Where(x => x.ListaEtapaPermissao.Any(p => idPremissoesGroup.Contains(p.ID)))
                                         .Select(x => new Usuario {
                    ID = x.ID
                })
                                         .ToList()
                                         .Select(x => new
                {
                    Usuario    = x,
                    Permissoes =
                        bmEtapaPermissao.ObterTodosIQueryable()
                        .Where(p => etapasIds.Contains(p.Etapa.ID) && p.Usuario != null && p.Usuario.ID == x.ID)
                        .Select(p => new { p.ID })
                        .Select(p => p.ID)
                        .ToList()
                }).ToList();

                foreach (var permissao in permissoes)
                {
                    permissao.Usuario =
                        usuariosPermissoes.FirstOrDefault(x => x.Permissoes.Any(pId => pId == permissao.ID))?.Usuario;
                }
            }

            var vinculoEtapaComEtapaResposta =
                bmEtapaResposta.ObterTodosIEnumerable().AsQueryable()
                .Where(x => etapasIds.Contains(x.Etapa.ID))
                .Select(x => new { EtapaId = x.Etapa.ID, EtapaRespostaId = x.ID })
                .ToList();

            foreach (var etapa in etapas)
            {
                etapa.Permissoes = permissoes.Where(p => p.Etapa.ID == etapa.ID).ToList();

                etapa.ListaEtapaResposta =
                    vinculoEtapaComEtapaResposta.Where(x => x.EtapaId == etapa.ID)
                    .Select(x => new EtapaResposta {
                    ID = x.EtapaRespostaId
                }).ToList();
            }

            var idsProcessosRespostasAbertos2 = idsProcessosRespostasAbertos.ToList();

            foreach (var etapaResposta in etapasRespostas)
            {
                etapaResposta.ProcessoResposta =
                    idsProcessosRespostasAbertos2.FirstOrDefault(pr => pr.ListaEtapaResposta.Any(er => er.ID == etapaResposta.ID));

                etapaResposta.Etapa =
                    etapas.AsEnumerable().FirstOrDefault(
                        x =>
                        x.ListaEtapaResposta
                        .Select(er => new { er.ID }).AsEnumerable()
                        .ToList()
                        .Any(er => er.ID == etapaResposta.ID));
            }

            var retorno = etapasRespostas.Where(er => UsuarioPodeAnalisar(diretores, er, numero, demandanteId,
                                                                          processoId, etapaId, usuario, cargos, somenteEtapasComUmAnalista)).ToList();

            //CASO ETAPA ENCAMINHADA PELO USUARIO ESTIVER PENDENTE, A ETAPA NAO EXIBE PARA O USUARIO
            retorno = retorno.Where(x => x.ListaEtapaEncaminhamentoUsuario != null && x.ListaEtapaEncaminhamentoUsuario.Select(y => y.UsuarioEncaminhamento.ID).Contains(usuario.ID) ?
                                    x.ListaEtapaEncaminhamentoUsuario.Any(z => z.UsuarioEncaminhamento.ID == usuario.ID && z.StatusEncaminhamento != (int)enumStatusEncaminhamentoEtapa.Aguardando)
                        : true).ToList();

            //CASO ETAPA ENCAMINHADA PELO USUARIO NAO ESTIVER PENDENTE, A ETAPA NAO EXIBE PARA O USUARIO
            retorno = retorno.Where(x => x.ListaEtapaEncaminhamentoUsuario != null && x.ListaEtapaEncaminhamentoUsuario.Select(y => y.EtapaPermissaoNucleo.HierarquiaNucleoUsuario.Usuario.ID).Contains(usuario.ID) ?
                                    x.ListaEtapaEncaminhamentoUsuario.Any(z => z.EtapaPermissaoNucleo.HierarquiaNucleoUsuario.Usuario.ID == usuario.ID && z.StatusEncaminhamento != (int)enumStatusEncaminhamentoEtapa.Negado)
                        : true).ToList();

            return(retorno);
        }