public async Task <RespostaCasoDeUso> Handle(ObterProcessoJuridicoQuery request, CancellationToken cancellationToken)
{
var processo = await Context.ProcessosJuridicos
.Include(p => p.Cliente)
.Include(p => p.Eventos)
.ThenInclude(e => e.Anexos)
.FirstOrDefaultAsync(p => p.Codigo == request.Codigo &&
p.CodigoEscritorio == ServicoUsuarios.EscritorioAtual.Codigo &&
!p.Apagado);
if (processo == null)
{
return(RespostaCasoDeUso.ComStatusCode(HttpStatusCode.NotFound));
}
var usuarioUltimaAlteracao = await ServicoUsuarios.ObterInformacoesDeUsuario(processo.CodigoUsuarioUltimaAlteracao);
var processoDto = ProcessoJuridico.FromEntity(processo);
processoDto.NomeUsuarioUltimaAlteracao = usuarioUltimaAlteracao.ObterNomeCompleto();
if (processoDto.CodigoAdvogadoResponsavel.HasValue)
{
var usuarioAdvogadoResponsavel = await ServicoUsuarios.ObterInformacoesDeUsuario(processoDto.CodigoAdvogadoResponsavel.Value);
processoDto.NomeAdvogadoResponsavel = usuarioUltimaAlteracao.ObterNomeCompleto();
}
return(RespostaCasoDeUso.ComSucesso(processoDto));
}
public async Task <RespostaCasoDeUso> Handle(CadastrarProcessoJuridicoCommand request, CancellationToken cancellationToken)
{
var usuarioAtual = await ServicoUsuarios.ObterInformacoesDeUsuario(ServicoUsuarios.UsuarioAtual.Codigo);
var processo = request.AsEntity();
if (processo.Invalid)
{
return(RespostaCasoDeUso.ComFalha(processo.Notifications));
}
if (usuarioAtual.EhAdministrador)
{
processo.AtualizarAdvogadoResponsavel(null);
}
else
{
processo.AtualizarAdvogadoResponsavel(ServicoUsuarios.UsuarioAtual.Codigo);
}
var clienteExiste = await Context.Clientes
.AnyAsync(c => c.Codigo == request.CodigoCliente &&
c.CodigoEscritorio == ServicoUsuarios.EscritorioAtual.Codigo &&
!c.Apagado);
if (!clienteExiste)
{
return(RespostaCasoDeUso.ComStatusCode(HttpStatusCode.NotFound));
}
var processoExiste = await Context.ProcessosJuridicos
.AnyAsync(p => p.Numero.Numero == request.NumeroProcesso &&
p.CodigoEscritorio == ServicoUsuarios.EscritorioAtual.Codigo &&
!p.Apagado);
if (processoExiste)
{
return(RespostaCasoDeUso.ComFalha("Já existe um processo com o mesmo número"));
}
await Context.ProcessosJuridicos.AddAsync(processo);
await Context.SaveChangesAsync();
return(RespostaCasoDeUso.ComSucesso(processo.Codigo));
}
public async Task <RespostaCasoDeUso> Handle(ListarProcessosJuridicosQuery request, CancellationToken cancellationToken)
{
var usuarioAtual = await ServicoUsuarios.ObterInformacoesDeUsuario(ServicoUsuarios.UsuarioAtual.Codigo);
var processos = await Context.ProcessosJuridicos
.Include(p => p.Cliente)
.Where(p => p.CodigoEscritorio == ServicoUsuarios.EscritorioAtual.Codigo && !p.Apagado && (p.CodigoAdvogadoResponsavel == usuarioAtual.Codigo || usuarioAtual.EhAdministrador))
.Select(p => new ProcessoJuridicoPreview
{
Codigo = p.Codigo,
CodigoAdvogadoResponsavel = p.CodigoAdvogadoResponsavel,
CodigoCliente = p.CodigoCliente,
NomeCliente = p.Cliente.Nome.PrimeiroNome,
NumeroProcesso = p.Numero.Numero,
Titulo = p.Titulo.Valor,
Status = p.Status,
UF = p.UF.UF,
TipoDePapel = p.TipoDePapel,
DataCriacao = p.DataCriacao,
DataUltimaAtualizacao = p.DataUltimaAlteracao
})
.ToListAsync();
Task.WaitAll(processos.Select(async processo =>
{
if (!processo.CodigoAdvogadoResponsavel.HasValue)
{
return;
}
processo.NomeAdvogadoResponsavel = (await ServicoUsuarios
.ObterInformacoesDeUsuario(processo.CodigoAdvogadoResponsavel.Value))
.ObterNomeCompleto();
}).ToArray());
var listagem = new ListagemProcessos
{
QuantidadeProcessos = processos.Count,
QuantidadeProcessosAtivos = processos.Count(p => p.Status != EStatusProcessoJuridico.Finalizado),
Processos = processos
};
return(RespostaCasoDeUso.ComSucesso(listagem));
}
public async static Task <Cliente> FromEntity(Dominio.Entidades.Cliente entidade, ServicoUsuarios servico)
{
var usuarioUltimaAlteracao = await servico.ObterInformacoesDeUsuario(entidade.CodigoUsuarioUltimaAlteracao);
var enderecos = entidade.Enderecos.Select(async e =>
{
var usuario = await servico.ObterInformacoesDeUsuario(e.CodigoUsuarioUltimaAlteracao);
return(new Endereco
{
Codigo = e.Codigo,
Rua = e.Rua,
Numero = e.Numero,
Complemento = e.Complemento,
Cidade = e.Cidade,
Estado = e.Estado,
Pais = e.Pais,
Cep = e.Cep,
Observacoes = e.Observacoes,
Tipo = e.Tipo,
DataCriacao = e.DataCriacao,
DataUltimaAlteracao = e.DataUltimaAlteracao,
NomeUsuarioUltimaAlteracao = usuario.ObterNomeCompleto()
});
});
var processos = entidade.Processos.Select(p => new ProcessoJuridico
{
Codigo = p.Codigo,
Numero = p.Numero.Numero,
Titulo = p.Titulo.Valor,
Descricao = p.Descricao.Valor,
JuizResponsavel = p.JuizResponsavel,
UF = p.UF.UF,
Status = p.Status.ToString(),
TipoDePapel = p.TipoDePapel.ToString(),
CodigoAdvogadoResponsavel = p.CodigoAdvogadoResponsavel,
CodigoCliente = p.CodigoCliente
});
var anexos = entidade.Anexos.Select(a => new Anexo {
Codigo = a.Codigo,
NomeArquivo = a.NomeArquivo
});
return(new Cliente
{
Codigo = entidade.Codigo,
Nome = entidade.Nome.PrimeiroNome,
Sobrenome = entidade.Nome.Sobrenome,
DataNascimento = entidade.DataNascimento.Data,
Email = entidade.Email.Endereco,
RG = entidade.RG.Numero,
CPF = entidade.CPF.Numero,
Enderecos = await Task.WhenAll(enderecos),
Anexos = anexos,
ProcessosJuridicos = processos,
DataCriacao = entidade.DataCriacao,
DataUltimaAlteracao = entidade.DataUltimaAlteracao,
NomeUsuarioUltimaAlteracao = usuarioUltimaAlteracao.ObterNomeCompleto()
});
}