Esempio n. 1
0
        private async Task ExportarAtividadesDoCaso(Guid userGuid, ProcessoBase processoCompleto)
        {
            List <RamosJudicialEnum> tiposDeCasoQueNaoPodemTerAudiencia = new List <RamosJudicialEnum>();

            tiposDeCasoQueNaoPodemTerAudiencia.Add(RamosJudicialEnum.Interno);
            tiposDeCasoQueNaoPodemTerAudiencia.Add(RamosJudicialEnum.InternoEscritorio);
            List <Audiencia> audienciasComSubTarefas = new List <Audiencia>();

            if (!processoCompleto.Tipo.HasValue || !tiposDeCasoQueNaoPodemTerAudiencia.Contains(processoCompleto.Tipo.Value))
            {
                audienciasComSubTarefas = await _compromissoAudienciaRepositorio.Listar(casoId : processoCompleto.Id);
            }
            List <Prazo> prazosComSubTarefas = await _prazoRepositorio.Listar(casoId : processoCompleto.Id);

            ValidaItensDeAgenda(audienciasComSubTarefas, prazosComSubTarefas);

            //por ora pego o cdforo do caso para as audiencias
            if (audienciasComSubTarefas != null && audienciasComSubTarefas.Count > 0)
            {
                PreencheListaAudiencia(audienciasComSubTarefas, processoCompleto.IdForo.Value);

                var   audienciasTask = _exportService.ExportarAudiencias(userGuid, audienciasComSubTarefas, processoCompleto.IdDefinitivo.Value);
                await audienciasTask;
            }

            if (prazosComSubTarefas != null && prazosComSubTarefas.Count > 0)
            {
                var   prazosTask = _exportService.ExportarPrazos(userGuid, prazosComSubTarefas, processoCompleto.IdDefinitivo.Value);
                await prazosTask;
            }
        }
Esempio n. 2
0
        public async Task <PrazoViewModel> ObterPrazo(Guid userGuid, int?prazoId, int?casoId)
        {
            PrazoViewModel vm = new PrazoViewModel();

            Prazo prazo = new Prazo();

            if (prazoId.HasValue && prazoId.Value > 0)
            {
                prazo = await _prazoRepositorio.Obter(prazoId.Value);
            }
            if (casoId.HasValue && casoId.Value > 0)
            {
                prazo.IdProcesso = casoId.Value;
            }

            vm = _mapper.Map <PrazoViewModel>(prazo);

            vm.HoraAtividade = prazo.DataCompromisso;
            if (prazo.IdProcesso.HasValue && prazo.IdProcesso > 0)
            {
                ProcessoBase caso = await _processoRepositorio.Obter(prazo.IdProcesso.Value);

                vm.Processo = string.IsNullOrEmpty(caso.Titulo) ? "Caso sem título. Cliente: " + caso.ClienteNome : caso.Titulo;
            }

            int?idTituloPai = null;

            if (prazo.IdPai.HasValue && prazo.IdPai.Value > 0)
            {
                Prazo pai = await _prazoRepositorio.Obter(prazo.IdPai.Value);

                idTituloPai = pai.IdTituloCobranca;
            }
            if (!casoId.HasValue || casoId.Value < 1)
            {
                try
                {
                    vm.PossiveisClientesDefinitivos = await _clienteService.ListarClientes(userGuid);
                }
                catch (Exception ex)
                {
                    throw new MemberAccessException("Sessão expirada");
                }
            }
            var taskExecutores    = _executorService.ListaPossiveisExecutores(userGuid, Domain.Models.TipoDeTarefaEnum.Prazo);
            var taskParticipantes = _profissionalService.ListarProfissionais(userGuid);
            var taskCategorias    = _categoriaDeProfissioalService.Lista(userGuid);
            var taskTitulos       = _tituloCobrancaService.ListaAsync(userGuid, Domain.Models.TipoDeTarefaEnum.Prazo, idTituloPai);

            await Task.WhenAll(taskExecutores, taskParticipantes, taskCategorias, taskTitulos);

            vm.PossiveisExecutores      = taskExecutores.Result;
            vm.TodosPossiveisExecutores = taskExecutores.Result;
            vm.PossiveisParticipantes   = taskParticipantes.Result;
            vm.PossiveisCategorias      = taskCategorias.Result;
            vm.PossiveisTitulos         = taskTitulos.Result;

            return(vm);
        }
Esempio n. 3
0
        public async Task <ProcessoBase> ObterProcessoComDadosComplementares(int processoId)
        {
            using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
            {
                ProcessoBaseBD response = await dbContext.Processos.Include(x => x.CamposComplementares).AsNoTracking().FirstOrDefaultAsync(x => x.Id == processoId);

                ProcessoBase retorno = response.ConverterParaModelo();

                return(retorno);
            }
        }
        public async Task <IEnumerable <CampoDadoComplementarViewModel> > ListarDadosComplementaresDoCaso(Guid userGuid, int idCaso)
        {
            ProcessoBase processo = await _processoRepositorio.ObterProcessoComDadosComplementares(idCaso);

            var campos = await _infraDadosComplementaresService.ObterCamposComplementaresDoCliente(userGuid, processo.IdCliente);

            if (campos != null)
            {
                campos = AtribuirValorAosCampos(campos, processo.CamposComplementares);
            }
            return(campos);
        }
Esempio n. 5
0
        public async Task <int> PersistirDados(ProcessoBase processoBase, Guid userGuid)
        {
            if (processoBase.PrecisaAtualizar())
            {
                var result = await _processoRepositorio.Atualizar(processoBase, userGuid);

                return(result.Id);
            }
            else
            {
                var result = await _processoRepositorio.CadastrarNovo(processoBase, userGuid);

                return(result.Id);
            }
        }
Esempio n. 6
0
        public async Task <ProcessoBase> ObterProcessoTarefasAndPolos(int processoId)
        {
            using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
            {
                ProcessoBaseBD response = await dbContext.Processos
                                          .Include(x => x.Audiencias)
                                          .Include(x => x.Prazos)
                                          .Include(x => x.Polos).ThenInclude(polo => polo.Parte)
                                          .AsNoTracking()
                                          .FirstOrDefaultAsync(x => x.Id == processoId);

                ProcessoBase retorno = response.ConverterParaModelo();

                return(retorno);
            }
        }
Esempio n. 7
0
        public async Task <ProcessoBase> ExportarCaso(Guid userGuid, ProcessoBase processo)
        {
            var context = _sessionContextData.ObterUserContext(userGuid);
            var ws      = new CEProcessoServiceSoapClient(soapConfiguration, context.UrlServico + ServicesUrlConstants.PROCESSO);

            var processoModel = _mapper.Map <MProcessoJudicialAdministrativo>(processo);

            processoModel = _preencheProcessoHelper.PreencheOutrosDados(processoModel, processo);
            processoModel.cdEscritorio = context.IdEscritorio;

            var novoProcesso = new IncluiRequest(context.ContextHeader, processoModel, context.NomeEscritorio);
            var retorno      = await ws.IncluiAsync(novoProcesso);

            processo.IdDefinitivo = retorno.IncluiResult;

            return(processo);
        }
Esempio n. 8
0
        public async Task <ProcessoBase> ListarCompleto(int id)
        {
            using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
            {
                ProcessoBaseBD response = await dbContext.Processos
                                          .Include(x => x.CamposComplementares)
                                          .Include(x => x.Polos).ThenInclude(polo => polo.Parte)
                                          //.ThenInclude(c=>c.Select(v=>v.Parte))
                                          //.Include("Polos.Parte.Advogados")
                                          //.Include("Polos.Parte.Empregos")
                                          //.Include("Polos.Parte.Enderecos")
                                          .AsNoTracking().FirstOrDefaultAsync(x => x.Id == id);


                ProcessoBase retorno = response.ConverterParaModelo();

                return(retorno);
            }
        }
Esempio n. 9
0
        public async Task <ProcessoBase> CadastrarNovo(ProcessoBase processo, Guid userGuid)
        {
            using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
            {
                processo.CriadoEm = DateTime.Now;

                var newProcesso = _mapper.Map <ProcessoBaseBD>(processo);

                await dbContext.Processos.AddAsync(newProcesso);

                dbContext.SaveUserGuidForLog(userGuid);

                await dbContext.SaveChangesAsync();

                var retorno = _mapper.Map <ProcessoBase>(dbContext.Processos.LastOrDefault());

                return(retorno);
            }
        }
Esempio n. 10
0
        public async Task <ProcessoBase> Atualizar(ProcessoBase processo, Guid userGuid)
        {
            using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
            {
                var processoDb = await dbContext.Processos.FindAsync(processo.Id);

                processo.AtualizadoEm = DateTime.Now;

                processoDb.Atualizar(_mapper.Map <ProcessoBaseBD>(processo));

                dbContext.Set <ProcessoBaseBD>().Update(processoDb);
                dbContext.SaveUserGuidForLog(userGuid);
                await dbContext.SaveChangesAsync();

                var retorno = _mapper.Map <ProcessoBase>(processoDb);

                return(retorno);
            }
        }
        internal ProcessoBaseBD ConverterDeModelo(ProcessoBase processo)
        {
            ProcessoBaseBD processoBaseBD = new ProcessoBaseBD
            {
                AnotacoesSegundoNumero = processo.AnotacoesSegundoNumero,
                Area         = processo.Area,
                AtualizadoEm = processo.AtualizadoEm,
                //Audiencias = processo.Audiencias.Select(aud => aud.ConverterDeModelo().ToArray()),
                //CamposComplementares= processo.CamposComplementares.Select(campo => campo.ConverterDeModelo().ToArray()),
                ClienteNome         = processo.ClienteNome,
                Confidencial        = processo.Confidencial,
                Contrato            = processo.Contrato,
                CriadoEm            = processo.CriadoEm,
                DataDistribuicao    = processo.DataDistribuicao,
                DataEntrada         = processo.DataEntrada,
                EnvolvimentoCliente = processo.EnvolvimentoCliente,
                estado           = processo.estado,
                estado_area      = processo.estado_area,
                Exito            = processo.Exito,
                Fase             = processo.Fase,
                Filial           = processo.Filial,
                Foro             = processo.Foro,
                ForoHierarquia   = processo.ForoHierarquia,
                GrupoForo        = processo.GrupoForo,
                IdArea           = processo.IdArea,
                IdCliente        = processo.IdCliente,
                IdContrato       = processo.IdContrato,
                IdFase           = processo.IdFase,
                IdFilial         = processo.IdFilial,
                IdForo           = processo.IdForo,
                IdForoVara       = processo.IdForoVara,
                IdGrupoFamilia   = processo.IdGrupoFamilia,
                IdGrupoForo      = processo.IdGrupoForo,
                IdPasta          = processo.IdPasta,
                IdRegiao         = processo.IdRegiao,
                IdRito           = processo.IdRito,
                MoedaFaturamento = processo.MoedaFaturamento,
                NomePasta        = processo.NomePasta,
                NumeroCompleto   = processo.NumeroCompleto,
                NumeroExterno    = processo.NumeroExterno,
                Observacoes      = processo.Observacoes,
                //Polos= processo.Polos.Select(polo => polo.ConverterDeModelo().ToArray()),
                //Prazos= processo.Prazos.Select(prazo => prazo.ConverterDeModelo().ToArray(),
                PrevisaoEncerramento = processo.PrevisaoEncerramento,
                Responsavel          = processo.Responsavel,
                Rito                  = processo.Rito,
                SegundoNumero         = processo.SegundoNumero,
                Tipo                  = processo.Tipo,
                TipoUpdate            = processo.TipoUpdate,
                Titulo                = processo.Titulo,
                ValorContigencia      = processo.ValorContigencia,
                ValorExpectativaCausa = processo.ValorExpectativaCausa,
                ValorInicialCausa     = processo.ValorInicialCausa,
                Vara                  = processo.Vara,
                IdDefinitivo          = processo.IdDefinitivo,
                Id            = processo.Id,
                IdResponsavel = processo.IdResponsavel,
            };

            return(processoBaseBD);
        }
        internal ProcessoBase ConverterParaModelo()
        {
            ProcessoBase processoBase = new ProcessoBase
            {
                AnotacoesSegundoNumero = this.AnotacoesSegundoNumero,
                Area                 = this.Area,
                AtualizadoEm         = this.AtualizadoEm,
                Audiencias           = this.Audiencias?.Select(aud => aud.ConverterParaModelo()).ToArray(),
                Polos                = this.Polos?.Select(polo => polo.Converter()).ToArray(),
                CamposComplementares = this.CamposComplementares?.Select(campo => campo.ConverterParaModelo()).ToArray(),
                ClienteNome          = this.ClienteNome,
                Confidencial         = this.Confidencial,
                Contrato             = this.Contrato,
                CriadoEm             = this.CriadoEm,
                DataDistribuicao     = this.DataDistribuicao,
                DataEntrada          = this.DataEntrada,
                EnvolvimentoCliente  = this.EnvolvimentoCliente,
                Escritorio           = this.Escritorio,
                estado               = this.estado,
                estado_area          = this.estado_area,
                Exito                = this.Exito,
                Exportado            = this.Exportado,
                Fase                 = this.Fase,
                Filial               = this.Filial,
                Foro                 = this.Foro,
                ForoHierarquia       = this.ForoHierarquia,
                GrupoForo            = this.GrupoForo,
                Id                    = this.Id,
                IdArea                = this.IdArea,
                IdCliente             = this.IdCliente,
                IdContrato            = this.IdContrato,
                IdDefinitivo          = this.IdDefinitivo,
                IdFase                = this.IdFase,
                IdFilial              = this.IdFilial,
                IdForo                = this.IdForo,
                IdForoVara            = this.IdForoVara,
                IdGrupoFamilia        = this.IdGrupoFamilia,
                IdGrupoForo           = this.IdGrupoForo,
                IdPasta               = this.IdPasta,
                IdRegiao              = this.IdRegiao,
                IdResponsavel         = this.IdResponsavel,
                IdRito                = this.IdRito,
                MoedaFaturamento      = this.MoedaFaturamento,
                NomePasta             = this.NomePasta,
                NumeroCompleto        = this.NumeroCompleto,
                NumeroExterno         = this.NumeroExterno,
                Observacoes           = this.Observacoes,
                Prazos                = this.Prazos?.Select(prazo => prazo.ConverterParaModelo()).ToArray(),
                PrevisaoEncerramento  = this.PrevisaoEncerramento,
                Responsavel           = this.Responsavel,
                Rito                  = Rito,
                SegundoNumero         = this.SegundoNumero,
                Tipo                  = this.Tipo,
                TipoUpdate            = this.TipoUpdate,
                Titulo                = this.Titulo,
                ValorContigencia      = this.ValorContigencia,
                ValorExpectativaCausa = this.ValorExpectativaCausa,
                ValorInicialCausa     = this.ValorInicialCausa,
                Vara                  = this.Vara,
            };

            return(processoBase);
        }
Esempio n. 13
0
        private async Task <ExportAtividadesResponse> ExportarAtividadesDoCaso(Guid userGuid, ProcessoBase processoCompleto)
        {
            var retorno = new ExportAtividadesResponse();
            List <RamosJudicialEnum> tiposDeCasoQueNaoPodemTerAudiencia = new List <RamosJudicialEnum>();

            tiposDeCasoQueNaoPodemTerAudiencia.Add(RamosJudicialEnum.Interno);
            tiposDeCasoQueNaoPodemTerAudiencia.Add(RamosJudicialEnum.InternoEscritorio);

            List <Audiencia> audienciasComSubTarefas = new List <Audiencia>();

            if (!processoCompleto.Tipo.HasValue || !tiposDeCasoQueNaoPodemTerAudiencia.Contains(processoCompleto.Tipo.Value))
            {
                audienciasComSubTarefas = await _compromissoAudienciaRepositorio.Listar(casoId : processoCompleto.Id);
            }

            List <Prazo> prazosComSubTarefas = await _prazoRepositorio.Listar(casoId : processoCompleto.Id);

            ValidaItensDeAgenda(audienciasComSubTarefas, prazosComSubTarefas);

            //por ora pego o cdforo do caso para as audiencias
            if (audienciasComSubTarefas != null && audienciasComSubTarefas.Count > 0)
            {
                PreencheListaAudiencia(audienciasComSubTarefas, processoCompleto.IdForo.Value);

                var audienciasTask = await _exportService.ExportarAudiencias(userGuid, audienciasComSubTarefas, processoCompleto.IdDefinitivo.Value);

                foreach (var item in audienciasTask.Atividades)
                {
                    AtividadeResponse response = new AtividadeResponse
                    {
                        Tarefa    = item.Tarefa,
                        Exportado = item.Exportado
                    };

                    retorno.Atividades.Add(response);
                }
            }

            if (prazosComSubTarefas != null && prazosComSubTarefas.Count > 0)
            {
                var prazosTask = await _exportService.ExportarPrazos(userGuid, prazosComSubTarefas, processoCompleto.IdDefinitivo.Value);

                foreach (var item in prazosTask.Atividades)
                {
                    AtividadeResponse response = new AtividadeResponse
                    {
                        Tarefa    = item.Tarefa,
                        Exportado = item.Exportado
                    };

                    retorno.Atividades.Add(response);
                }
            }

            return(retorno);
        }
Esempio n. 14
0
        public async Task <AudienciaViewModel> ObterAudiencia(Guid userGuid, int?audienciaId, int?idCaso)
        {
            AudienciaViewModel  vm           = new AudienciaViewModel();
            HierarquiaViewModel hierarquiaVM = new HierarquiaViewModel();

            Audiencia audiencia = new Audiencia();

            if (audienciaId.HasValue && audienciaId.Value > 0)
            {
                audiencia = await _audienciaRepositorio.Obter(audienciaId.Value);
            }
            if (idCaso.HasValue && idCaso.Value > 0)
            {
                audiencia.IdProcesso = idCaso.Value;
            }

            vm = _mapper.Map <AudienciaViewModel>(audiencia);

            vm.HoraAtividade = audiencia.DataAtividade;

            if (audiencia.IdProcesso.HasValue && audiencia.IdProcesso > 0)
            {
                ProcessoBase caso = await _processoRepositorio.Obter(audiencia.IdProcesso.Value);

                vm.Processo             = string.IsNullOrEmpty(caso.Titulo) ? "Caso sem título. Cliente: " + caso.ClienteNome : caso.Titulo;
                vm.TipoDoCaso           = caso.Tipo;
                vm.ForoDoCaso           = caso.ForoHierarquia;
                hierarquiaVM.ProcessoId = caso.Id;
                vm.IDForoDoCaso         = caso.IdForoVara;
                vm.LocalAudiencia       = caso.ForoHierarquia;
            }

            //if (audiencia.IdForo.HasValue && audiencia.IdForo.Value > 0)
            //{
            //    GrupoForo grupoForoSelecionado = await _hierarquiaService.ObtemPorForo(userGuid, audiencia.IdForo.Value);
            //    vm.IdForo = audiencia.IdForo;
            //    vm.IdGrupoFamilia = (int)grupoForoSelecionado.Instancia;
            //    vm.IdGrupoForo = grupoForoSelecionado.IdGrupoPai > 0 ? grupoForoSelecionado.IdGrupoPai : grupoForoSelecionado.Id;
            //    vm.Regiao = grupoForoSelecionado.Regiao;
            //    vm.UF = grupoForoSelecionado.UF;
            //}

            if (!idCaso.HasValue || idCaso.Value < 1)
            {
                vm.PossiveisClientesDefinitivos = await _clienteService.ListarClientes(userGuid);
            }

            var taskExecutores    = _executorService.ListaPossiveisExecutores(userGuid, Domain.Models.TipoDeTarefaEnum.Audiencia);
            var taskParticipantes = _profissionalService.ListarProfissionais(userGuid);
            var taskCategorias    = _categoriaDeProfissioalService.Lista(userGuid);
            int?idTituloPai       = null;

            if (audiencia.IdPai.HasValue && audiencia.IdPai > 0)
            {
                Audiencia pai = await _audienciaRepositorio.Obter(audiencia.IdPai.Value);

                idTituloPai = pai.IdTituloCobranca;
            }

            var taskTitulos = _tituloCobrancaService.ListaAsync(userGuid, Domain.Models.TipoDeTarefaEnum.Audiencia, idTituloPai);

            await Task.WhenAll(taskExecutores, taskParticipantes, taskCategorias, taskTitulos);

            vm.PossiveisExecutores      = taskExecutores.Result;
            vm.TodosPossiveisExecutores = taskExecutores.Result;
            vm.PossiveisParticipantes   = taskParticipantes.Result;
            vm.PossiveisCategorias      = taskCategorias.Result;
            vm.PossiveisTitulos         = taskTitulos.Result;

            return(vm);
        }
Esempio n. 15
0
        public MProcessoJudicialAdministrativo PreencheOutrosDados(MProcessoJudicialAdministrativo processoModel, ProcessoBase processo)
        {
            PreencheDadosPolos(processoModel, processo.Polos);
            PreencheListaHierarquia(processoModel, processo.ForoHierarquia);
            PreencherDadosHardcoded(processoModel);

            return(processoModel);
        }