public ActionResult ObterProcessosDocumentos(int protocoloId)
        {
            List <Protocolos> lstProcessosDocumentos = _busTitulo.ObterProcessosDocumentos(protocoloId);
            IProtocolo        proc = _busProtocolo.Obter(protocoloId);

            if (!_bus.ValidarAssociar(proc, Usuario.EtramiteIdentity.FuncionarioId))
            {
                return(Json(new
                {
                    @EhValido = Validacao.EhValido,
                    @Msg = Validacao.Erros
                },
                            JsonRequestBehavior.AllowGet));
            }



            Empreendimento emp = new EmpreendimentoBus().Obter(proc.Empreendimento.Id);

            return(Json(new
            {
                @EhValido = Validacao.EhValido,
                @Msg = Validacao.Erros,
                @ProcessosDocumentos = lstProcessosDocumentos,
                @Empreendimento = emp,
                @DeclaranteLst = _bus.ObterResponsaveis(emp.Id)
            },
                        JsonRequestBehavior.AllowGet));
        }
Example #2
0
        public ActionResult Analisar(int protocoloId = 0, int requerimentoId = 0)
        {
            AnaliseItemVM vm = new AnaliseItemVM();

            if (protocoloId == 0 || requerimentoId == 0)
            {
                return(View(vm));
            }

            IProtocolo  protocolo = _protocoloBus.Obter(protocoloId);
            AnaliseItem analise   = _bus.VerificarProtocolo(protocolo.Numero);

            if (!Validacao.EhValido)
            {
                return(RedirectToAction("Analisar", "AnaliseItens", Validacao.QueryParamSerializer()));
            }

            vm.Requerimentos           = analise.Requerimentos;
            vm.RequerimentoSelecionado = requerimentoId;
            vm.ProjetoDigitalId        = _busProjetoDigitalCredenciado.ObterProjetoDigitalId(requerimentoId);
            vm.ProtocoloId             = protocoloId;
            vm.ProtocoloNumero         = protocolo.Numero;

            Requerimento req = vm.Requerimentos.FirstOrDefault(x => x.Id == requerimentoId);

            AnaliseItem analiseAux = _bus.ObterPorChecagem(req.Checagem);

            if (analiseAux != null && analiseAux.Id > 0)
            {
                analise.Id       = analiseAux.Id;
                analise.Situacao = analiseAux.Situacao;
            }

            if (_validar.ValidarProtocoloAnalisar(req.Checagem, req.Id, protocolo.IsProcesso))
            {
                if (_validar.Analise(analise))
                {
                    // Caso não exista a analise na entrada no metodo abaixo a mesma vai ser criada
                    analise      = _bus.ObterAnaliseProtocolo(req, protocolo.Id.GetValueOrDefault(), false);
                    vm.AnaliseId = analise.Id;

                    vm.CheckListId = req.Checagem;
                    vm.Atualizado  = false;
                    vm.Roteiros    = analise.Roteiros;

                    analise.Itens.ForEach(x => x.Analista = string.Empty);
                    vm.ListarItens = analise.Itens;
                }
            }

            vm.Situacao            = analise.Situacao;
            vm.UrlsCaracterizacoes = ObterUrlsCaracterizacoes(_busCaracterizacao.ObterCaracterizacoes(vm.ProjetoDigitalId));

            return(View(vm));
        }
        public ActionResult Visualizar(int id)
        {
            IProtocolo protocolo = _bus.Obter(id);

            if (!Validacao.EhValido)
            {
                return(RedirectToAction("Index", Validacao.QueryParamSerializer()));
            }

            if (protocolo.IsProcesso)
            {
                Processo   processo = protocolo as Processo;
                ProcessoVM vm       = new ProcessoVM(_busLista.TiposProcesso, processo.Tipo.Id);
                vm.RequerimentoVM.IsVisualizar           = true;
                vm.RequerimentoVM.IsRequerimentoProcesso = true;
                vm.SetProcesso(processo, _busLista.ResponsavelFuncoes);

                vm.IsEditar = false;
                vm.RequerimentoVM.IsEditar = false;


                if (Request.IsAjaxRequest())
                {
                    return(PartialView("ProcessoVisualizarModal", vm));
                }
                else
                {
                    return(View("ProcessoVisualizar", vm));
                }
            }
            else
            {
                Documento   documento = protocolo as Documento;
                DocumentoVM vm        = new DocumentoVM(_busLista.TiposDocumento, documento.Tipo.Id);
                vm.SetDocumento(documento, _busLista.ResponsavelFuncoes);
                vm.RequerimentoVM.IsVisualizar = true;

                if (Request.IsAjaxRequest())
                {
                    return(PartialView("DocumentoVisualizarModal", vm));
                }
                else
                {
                    return(View("DocumentoVisualizar", vm));
                }
            }
        }
Example #4
0
        public bool PreDesarquivar(ListarTramitacaoFiltro filtros)
        {
            if (filtros.ArquivoId <= 0)
            {
                Validacao.Add(Mensagem.Arquivamento.DesarquivarArquivoObrigatorio);
                return(Validacao.EhValido);
            }

            if (String.IsNullOrWhiteSpace(filtros.Protocolo.NumeroTexto))
            {
                Validacao.Add(Mensagem.Arquivamento.DesarquivarProtocoloNumeroObrigatorio);
                return(Validacao.EhValido);
            }
            else
            {
                if (!filtros.Protocolo.IsValido)
                {
                    Validacao.Add(Mensagem.Arquivamento.DesarquivarProtocoloNumeroInvalido);
                    return(Validacao.EhValido);
                }
            }

            IProtocolo proc = _busProtocolo.Obter(filtros.Protocolo.NumeroTexto);

            if (proc == null || proc.Id.GetValueOrDefault() <= 0)
            {
                Validacao.Add(Mensagem.Arquivamento.DesarquivarProtocoloNaoCadastrado);
            }
            else
            {
                if (filtros.Protocolo.IsValido)
                {
                    return(Validacao.EhValido);
                }

                int setorProtocolo = proc.SetorId > 0 ? proc.SetorId : proc.SetorCriacaoId;

                if (setorProtocolo != filtros.RemetenteSetorId)
                {
                    Validacao.Add(Mensagem.Arquivamento.DesarquivarProtocoloEmOutroSetor);
                }
            }

            return(Validacao.EhValido);
        }
        private CobrancaVM GetCobrancaVM(int?cobrancaId, int?fiscalizacaoId = null, bool visualizar = false, int?index = null, Cobranca entidade = null)
        {
            var cobranca = entidade ?? (fiscalizacaoId > 0 ? _bus.ObterByFiscalizacao(fiscalizacaoId.GetValueOrDefault(0)) :
                                        _bus.Obter(cobrancaId.GetValueOrDefault(0))) ?? new Cobranca();

            if (fiscalizacaoId > 0)
            {
                cobranca.NumeroFiscalizacao = fiscalizacaoId;
            }

            if (entidade != null)
            {
                cobranca.Notificacao   = _busNotificacao.Obter(entidade.NumeroFiscalizacao.GetValueOrDefault(0));
                cobranca.Parcelamentos = _bus.ObterCobrancaParcelamento(cobranca.Id);
            }
            var maximoParcelas = 0;

            var fiscalizacao = _busFiscalizacao.Obter(cobranca.NumeroFiscalizacao.GetValueOrDefault(0));

            fiscalizacao.AutuadoPessoa = fiscalizacao.AutuadoPessoa.Id > 0 ? fiscalizacao.AutuadoPessoa : _busPessoa.Obter(fiscalizacao.LocalInfracao.ResponsavelId.GetValueOrDefault(0));
            if (cobranca.Id == 0)
            {
                var notificacao = _busNotificacao.Obter(cobranca.NumeroFiscalizacao.GetValueOrDefault(0)) ?? new Notificacao();
                var protocolo   = fiscalizacao.ProtocoloId > 0 ? _busProtocolo.Obter(fiscalizacao.ProtocoloId) : new Protocolo();
                cobranca = entidade ?? new Cobranca(fiscalizacao, protocolo, notificacao);
                if (entidade != null && entidade.ObterFiscalizacao)
                {
                    cobranca = new Cobranca(fiscalizacao, protocolo, notificacao);
                }
                cobranca.NumeroAutuacao = protocolo?.NumeroAutuacao;
                if ((cobranca.Parcelamentos?.Count ?? 0) == 0)
                {
                    cobranca.Parcelamentos = new List <CobrancaParcelamento>();
                    if (cobranca.UltimoParcelamento.ValorMulta == 0)
                    {
                        cobranca.UltimoParcelamento.ValorMulta = cobranca.UltimoParcelamento.ValorMultaAtualizado;
                    }
                    cobranca.Parcelamentos.Add(cobranca.UltimoParcelamento);
                }

                var parcelamento = cobranca.Parcelamentos[0];
                maximoParcelas = _bus.GetMaximoParcelas(cobranca, parcelamento);
                if (parcelamento.QuantidadeParcelas == 0)
                {
                    parcelamento.QuantidadeParcelas = 1;
                }
                parcelamento.DUAS = new List <CobrancaDUA>();
            }
            else
            {
                if ((cobranca.Parcelamentos?.Count ?? 0) == 0)
                {
                    cobranca.Parcelamentos = new List <CobrancaParcelamento>();
                    if (cobranca.UltimoParcelamento?.ValorMulta == 0)
                    {
                        cobranca.UltimoParcelamento.ValorMulta = cobranca.UltimoParcelamento.ValorMultaAtualizado;
                    }
                    cobranca.Parcelamentos.Add(cobranca.UltimoParcelamento);
                }

                var parcelamento = index.HasValue ? cobranca.Parcelamentos[index.Value] : cobranca.UltimoParcelamento ?? cobranca.Parcelamentos.FindLast(x => Convert.ToBoolean(x?.DataEmissao?.IsValido)) ?? new CobrancaParcelamento(fiscalizacao);
                maximoParcelas = _bus.GetMaximoParcelas(cobranca, parcelamento);

                if (cobranca.Parcelamentos?.Count == 0 || parcelamento?.DUAS?.Count == 0)
                {
                    if (parcelamento.QuantidadeParcelas == 0)
                    {
                        parcelamento.QuantidadeParcelas = 1;
                    }
                    parcelamento.DUAS = new List <CobrancaDUA>();
                    if ((cobranca.Parcelamentos?.Count ?? 0) == 0)
                    {
                        cobranca.Parcelamentos = new List <CobrancaParcelamento>();
                        cobranca.Parcelamentos.Add(parcelamento);
                    }
                }
            }

            var ultimoParcelamento = cobranca.UltimoParcelamento ?? cobranca.Parcelamentos.FindLast(x => Convert.ToBoolean(x?.DataEmissao?.IsValido)) ?? new CobrancaParcelamento(fiscalizacao);

            if ((ultimoParcelamento.QuantidadeParcelas > 0 && ultimoParcelamento.DUAS.Count == 0) || entidade != null)
            {
                if ((ultimoParcelamento.DUAS?.Count(x => x.Id > 0) ?? 0) == 0)
                {
                    ultimoParcelamento.DUAS = _bus.GerarParcelas(cobranca, ultimoParcelamento);
                }
                _bus.CalcularParcelas(cobranca, ultimoParcelamento);
            }

            if (fiscalizacao?.Id > 0)
            {
                cobranca.FiscalizacaoId = fiscalizacao.Id;
            }
            var vm = new CobrancaVM(cobranca, _busLista.InfracaoCodigoReceita, maximoParcelas, visualizar, index);

            if (fiscalizacao != null)
            {
                vm.SituacaoFiscalizacao = ViewModelHelper.CriarSelectList(_busLista.FiscalizacaoSituacao.Where(x => x.Id == fiscalizacao.SituacaoId.ToString()).ToList(), null, false);
            }
            vm.Series                 = ViewModelHelper.CriarSelectList(_busLista.FiscalizacaoSerie, true, true, selecionado: cobranca.SerieId?.ToString());
            vm.ArquivoVM.Anexos       = cobranca.Anexos ?? new List <Anexo>();
            vm.ArquivoVM.IsVisualizar = visualizar;

            return(vm);
        }