Example #1
0
        public ActionResult ObterProtocolo(int id, bool isProcesso)
        {
            List <PessoaLst> lista     = _busProtocolo.ObterInteressadoRepresentantes(id);
            IProtocolo       protocolo = _busProtocolo.ObterSimplificado(id);

            if (lista.Count == 0)
            {
                lista.Add(new PessoaLst()
                {
                    Id = protocolo.Interessado.Id
                });
            }
            return(Json(new
            {
                @EhValido = Validacao.EhValido,
                @Msg = Validacao.Erros,
                @Objeto = new
                {
                    @Id = id,
                    @Numero = protocolo.Numero,
                    @EmpreendimentoId = protocolo.Empreendimento.Id,
                    @EmpreendimentoNome = protocolo.Empreendimento.Denominador,
                    @Interessado = protocolo.Interessado,
                    @Representantes = lista
                }
            }));
        }
Example #2
0
        public bool Salvar(PecaTecnica pecaTecnica)
        {
            if (pecaTecnica.Elaborador <= 0)
            {
                Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaElaboradorObrigatorio);
            }

            if (pecaTecnica.Atividade <= 0)
            {
                Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaAtividadeObrigatorio);
            }

            if (pecaTecnica.ResponsaveisEmpreendimento.Count <= 0)
            {
                Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaRespEmpreendimentoObrigatorio);
            }

            if (pecaTecnica.ElaboradorTipoEnum == eElaboradorTipo.TecnicoIdaf && pecaTecnica.SetorCadastro <= 0)
            {
                Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaSetorObrigatorio);
            }

            if (!Validacao.EhValido)
            {
                return(false);
            }

            IProtocolo protocolo = _busProtocolo.ObterSimplificado(pecaTecnica.Protocolo.Id.GetValueOrDefault());

            if (protocolo.Empreendimento.Id <= 0)
            {
                Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaNaoPossuiEmpreendimento);
                return(false);
            }

            List <Requerimento> requerimentos = _busProtocolo.ObterProtocoloRequerimentos(pecaTecnica.ProtocoloPai.GetValueOrDefault());

            if (!requerimentos.Exists(x => x.ProtocoloId == pecaTecnica.Protocolo.Id))
            {
                Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaRequerimentoNaoAssociado);
                return(false);
            }

            ProjetoGeograficoBus busProjetoGeo = new ProjetoGeograficoBus();

            int projetoGeoId = busProjetoGeo.ExisteProjetoGeografico(pecaTecnica.Protocolo.Empreendimento.Id, (int)eCaracterizacao.Dominialidade);

            if (busProjetoGeo.ObterSitacaoProjetoGeografico(projetoGeoId) != (int)eProjetoGeograficoSituacao.Finalizado)
            {
                Validacao.Add(Mensagem.AnaliseItem.PecaTecnicaProjetoDeveSerFinalizado);
            }


            return(Validacao.EhValido);
        }
Example #3
0
        public ActionResult ObterPecaTecnicaConteudo(int id, int protocoloId)
        {
            int pecaTecnicaId = _busPecaTecnica.ExistePecaTecnica(id, protocoloId);

            PecaTecnica pecaTecnica = pecaTecnicaId > 0 ? _busPecaTecnica.Obter(pecaTecnicaId) : new PecaTecnica();

            PecaTecnicaVM vm = new PecaTecnicaVM(pecaTecnica);

            List <int> tiposDestinatario = new List <int>()
            {
                (int)eEmpreendimentoResponsavelTipo.Proprietario,
                (int)eEmpreendimentoResponsavelTipo.Socio,
                (int)eEmpreendimentoResponsavelTipo.Herdeiro,
                (int)eEmpreendimentoResponsavelTipo.Posseiro
            };

            vm.PecaTecnica.Protocolo = _protocoloBus.ObterSimplificado(protocoloId);

            if (pecaTecnicaId > 0)
            {
                List <PessoaLst> responsaveisTecnicos;
                if (vm.PecaTecnica.ElaboradorTipoEnum == eElaboradorTipo.TecnicoIdaf)
                {
                    vm.Setores = ViewModelHelper.CriarSelectList(_busFuncionario.ObterSetoresFuncionario());

                    EtramiteIdentity func = User.Identity as EtramiteIdentity ?? new EtramiteIdentity("", "", "", null, "", 0, 0, "", "", 0, 0);
                    responsaveisTecnicos = new List <PessoaLst>();
                    responsaveisTecnicos.Add(new PessoaLst()
                    {
                        Texto = func.Name, Id = func.UsuarioId
                    });
                }
                else
                {
                    responsaveisTecnicos = _protocoloBus.ObterResponsaveisTecnicos(vm.PecaTecnica.Protocolo.Id.GetValueOrDefault());
                }

                vm.Elaboradores = ViewModelHelper.CriarSelectList(responsaveisTecnicos, itemTextoPadrao: responsaveisTecnicos.Count != 1);
            }

            List <PessoaLst> responsaveis = _busEmpreendimento.ObterResponsaveis(vm.PecaTecnica.Protocolo.Empreendimento.Id).Where(x => tiposDestinatario.Contains(x.VinculoTipo)).ToList();

            vm.RespEmpreendimento = ViewModelHelper.CriarSelectList <PessoaLst>(responsaveis, itemTextoPadrao: responsaveis.Count != 1);

            string html = ViewModelHelper.RenderPartialViewToString(ControllerContext, "PecaTecnicaConteudo", vm);

            return(Json(new { EhValido = true, Msg = Validacao.Erros, html = html }));
        }
        public ActionResult Historico(int id, int tipo)
        {
            HistoricoVM vm = new HistoricoVM();

            ListarTramitacaoFiltro filtro = new ListarTramitacaoFiltro();

            filtro.Protocolo.Id         = id;
            filtro.Protocolo.IsProcesso = (tipo == (int)eTipoProtocolo.Processo);

            Resultados <Tramitacao>         hstTramitacao = _bus.FiltrarHistorico(filtro);
            Resultados <HistoricoProtocolo> hstProtocolo;
            IProtocolo protocolo = new Protocolo();

            hstProtocolo = _busProtocolo.FiltrarHistoricoAssociados(new ListarProtocoloFiltro()
            {
                Id          = id,
                ProtocoloId = filtro.Protocolo.IsProcesso ? (int)eTipoProtocolo.Processo : (int)eTipoProtocolo.Documento
            });

            protocolo                  = _busProtocolo.ObterSimplificado(id);
            vm.TipoHistorico           = filtro.Protocolo.IsProcesso ? "Processo" : "documento";
            vm.TipoHistoricoId         = tipo;
            vm.AcaoHistoricoMostrarPdf = _bus.ObterHistoricoAcoesMostrarPdf();
            vm.CarregarHistorico(hstTramitacao.Itens, hstProtocolo, protocolo.Numero, protocolo.Tipo.Texto);

            ProtocoloLocalizacao loc = _busProtocolo.ObterLocalizacao(id);

            if (loc.Localizacao == eLocalizacaoProtocolo.OrgaoExterno)
            {
                vm.Localizacao = loc.OrgaoExternoNome;
            }
            else if (loc.Localizacao == eLocalizacaoProtocolo.Arquivado)
            {
                vm.Localizacao = loc.ArquivoNome;
            }
            else if (loc.Localizacao == eLocalizacaoProtocolo.EnviadoParaSetor || loc.Localizacao == eLocalizacaoProtocolo.EnviadoParaFuncionario)
            {
                vm.Localizacao = "Em tramitação";
            }
            else if (loc.ProcessoPaiId > 0 || loc.Localizacao == eLocalizacaoProtocolo.PosseFuncionario)
            {
                vm.Localizacao = loc.SetorDestinatarioNome;
            }

            return(PartialView("HistoricoPartial", vm));
        }