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;
}
}
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);
}
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);
}
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);
}
}
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);
}
}
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);
}
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);
}
}
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);
}
}
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);
}
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);
}
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);
}
public MProcessoJudicialAdministrativo PreencheOutrosDados(MProcessoJudicialAdministrativo processoModel, ProcessoBase processo)
{
PreencheDadosPolos(processoModel, processo.Polos);
PreencheListaHierarquia(processoModel, processo.ForoHierarquia);
PreencherDadosHardcoded(processoModel);
return(processoModel);
}
