Пример #1
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);
        }
Пример #2
0
        public async Task <ExportAtividadesResponse> ExportarPrazos(Guid userGuid, List <Prazo> prazos, int idProcessoDefinitivo)
        {
            var retorno = new ExportAtividadesResponse();

            if (prazos != null)
            {
                TransformaZerosEmNulosLawOffice(prazos);

                foreach (Prazo prazo in prazos)
                {
                    try
                    {
                        var prazoResponse = await ExportarPrazo(userGuid, prazo, idProcessoDefinitivo);

                        AtividadeResponse response = new AtividadeResponse
                        {
                            Tarefa    = prazoResponse.Keys.FirstOrDefault(),
                            Exportado = prazoResponse.Values.FirstOrDefault()
                        };

                        retorno.Atividades.Add(response);
                    }
                    catch (Exception ex)
                    {
                        AtividadeResponse response = new AtividadeResponse
                        {
                            Tarefa    = _mapper.Map <Atividade>(prazo),
                            Exportado = false
                        };

                        retorno.Atividades.Add(response);
                    }
                }
            }

            return(retorno);
        }
Пример #3
0
        public async Task <ExportAtividadesResponse> ExportarAudiencias(Guid userGuid, List <Audiencia> audiencias, int idProcessoDefinitivo)
        {
            var retorno = new ExportAtividadesResponse();

            if (audiencias != null)
            {
                TransformaZerosEmNulosLawOffice(audiencias);

                foreach (Audiencia audi in audiencias)
                {
                    try
                    {
                        var aud = await ExportarAudiencia(userGuid, audi, idProcessoDefinitivo);

                        AtividadeResponse response = new AtividadeResponse {
                            Tarefa    = aud.Keys.FirstOrDefault(),
                            Exportado = aud.Values.FirstOrDefault()
                        };

                        retorno.Atividades.Add(response);
                    }
                    catch (Exception ex)
                    {
                        AtividadeResponse response = new AtividadeResponse
                        {
                            Tarefa    = _mapper.Map <Atividade>(audi),
                            Exportado = false
                        };

                        retorno.Atividades.Add(response);
                    }
                }
            }

            return(retorno);
        }
Пример #4
0
        public async Task <ExportAtividadesResponse> ExportarAtividades(Guid userGuid, List <int> idAudiencias, List <int> idPrazos)
        {
            ExportAtividadesResponse retorno = new ExportAtividadesResponse();

            var audienciasTask = await _compromissoAudienciaRepositorio.Listar(idAudiencias);

            var prazosTask = await _prazoRepositorio.Listar(idPrazos);

            if (audienciasTask.Count > 0)
            {
                PreencheListaAudiencia(audienciasTask);

                var group = audienciasTask.GroupBy(x => x.IdProcesso);

                foreach (var grupoAudiencias in group)
                {
                    var aud = await _exportService.ExportarAudiencias(userGuid, grupoAudiencias.ToList(), grupoAudiencias.FirstOrDefault().Processo.IdDefinitivo.Value);

                    foreach (var item in aud.Atividades)
                    {
                        if (item.Exportado)
                        {
                            await _compromissoAudienciaRepositorio.MarcarExportadoAsync(_mapper.Map <Audiencia>(item.Tarefa), userGuid);

                            AtividadeResponse response = new AtividadeResponse
                            {
                                Tarefa    = item.Tarefa,
                                Exportado = item.Exportado
                            };

                            retorno.Atividades.Add(response);
                        }
                        else
                        {
                            AtividadeResponse response = new AtividadeResponse
                            {
                                Tarefa    = item.Tarefa,
                                Exportado = item.Exportado
                            };

                            retorno.Atividades.Add(response);
                        }
                    }
                }
            }

            if (prazosTask.Count > 0)
            {
                var group = prazosTask.GroupBy(x => x.IdProcesso);

                foreach (var grupoPrazos in group)
                {
                    var aud = await _exportService.ExportarPrazos(userGuid, grupoPrazos.ToList(), grupoPrazos.FirstOrDefault().Processo.IdDefinitivo.Value);

                    foreach (var item in aud.Atividades)
                    {
                        if (item.Exportado)
                        {
                            await _prazoRepositorio.MarcarExportado(_mapper.Map <Prazo>(item.Tarefa), userGuid);

                            AtividadeResponse response = new AtividadeResponse
                            {
                                Tarefa    = item.Tarefa,
                                Exportado = item.Exportado
                            };

                            retorno.Atividades.Add(response);
                        }
                        else
                        {
                            AtividadeResponse response = new AtividadeResponse
                            {
                                Tarefa    = item.Tarefa,
                                Exportado = item.Exportado
                            };

                            retorno.Atividades.Add(response);
                        }
                    }
                }
            }

            return(retorno);
        }