public async Task <JsonReturn> ListarAudiencias(string startString, string endString, string assunto = "")
{
var retorno = new JsonReturn();
var filter = new AtribuicaoFilter();
if (!string.IsNullOrEmpty(startString) && !string.IsNullOrEmpty(endString))
{
filter.Start = DateTime.Parse(startString);
filter.End = DateTime.Parse(endString);
}
filter.Assunto = assunto;
userGuid = new Guid(Helpers.RetrieveUserClaimGuid(HttpContext));
int domainGuid;
if (userGuid != null)
{
domainGuid = _sessionService.ObterIdEscritorioUsuario(userGuid);
}
else
{
throw new NullReferenceException("Erro(1)");
}
if (domainGuid != null)
{
retorno.Object = await _agendaService.ObterAudienciasDistribuicao(domainGuid, filter);
}
return(retorno);
}
public async Task <JsonReturn> ListarPrazos(string assunto, int?cliente, int?area)
{
var retorno = new JsonReturn();
var filter = new AtribuicaoFilter()
{
Cliente = cliente,
Area = area,
Assunto = assunto
};
userGuid = new Guid(Helpers.RetrieveUserClaimGuid(HttpContext));
int domainGuid;
if (userGuid != null)
{
domainGuid = _sessionService.ObterIdEscritorioUsuario(userGuid);
}
else
{
throw new NullReferenceException("Erro(1)");
}
if (domainGuid != null)
{
retorno.Object = await _agendaService.ObterTarefasDistribuicao(domainGuid, filter);
}
return(retorno);
}
private List <FuncionarioViewModel> ApplyEmployeesFilters(AtribuicaoFilter searchFilter, List <FuncionarioViewModel> liFuncionarios)
{
if (searchFilter.Area.HasValue)
{
liFuncionarios = liFuncionarios.Where(x => x.IdArea == searchFilter.Area.Value).ToList();
}
return(liFuncionarios);
}
public async Task <List <Prazo> > ListarPrazos(AtribuicaoFilter filter)
{
using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
{
var qry = dbContext.Prazos
.Include(x => x.Participantes)
.Include(x => x.Processo)
.Include(x => x.SubTarefas)
.AsQueryable();
//qry.FiltrarPrazo(filter);
return(_mapper.Map <List <Prazo> >(await qry.ToListAsync()));
}
}
private List <Audiencia> ApplyAudienciasFilters(AtribuicaoFilter searchFilter, List <Audiencia> liAudiencias)
{
if (!string.IsNullOrEmpty(searchFilter.Assunto))
{
liAudiencias = liAudiencias.Where(x => x.Assunto.Contains(searchFilter.Assunto)).ToList();
}
if (searchFilter.Start != null && searchFilter.End != null)
{
liAudiencias = liAudiencias.Where(c => c.DataAtividade >= searchFilter.Start && c.DataAtividade <= searchFilter.End).ToList();
}
return(liAudiencias);
}
private List <Prazo> ApplyPrazosFilters(AtribuicaoFilter searchFilter, List <Prazo> liPrazos)
{
if (!string.IsNullOrEmpty(searchFilter.Assunto))
{
liPrazos = liPrazos.Where(x => x.Assunto.Contains(searchFilter.Assunto)).ToList();
}
if (searchFilter.Start != null && searchFilter.End != null)
{
liPrazos = liPrazos.Where(c => c.DataCompromisso >= searchFilter.Start && c.DataCompromisso <= searchFilter.End).ToList();
}
return(liPrazos);
}
public async Task <List <Audiencia> > ListarAudiencias(AtribuicaoFilter filter)
{
using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
{
var qry = dbContext.CompromissosAudiencia
//.Include(x => x.Participantes)
//.Include(x => x.Processo)
//.Include(x => x.SubTarefas)
.AsQueryable();
//_mapper.Map<Audiencia>(qry).FiltrarAudiencias(filter);
return(_mapper.Map <List <Audiencia> >(await qry.ToListAsync()));
}
}
public async Task <List <Audiencia> > ListarAudienciasSemExecutor(AtribuicaoFilter filter, int domainGuid)
{
using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
{
var qry = await dbContext.CompromissosAudiencia
//.Include(x => x.Participantes)
//.Include(x => x.Processo)
.Include(x => x.SubTarefas)
.Where(x => x.IdExecutor == null).ToListAsync();
// qry = qry.FiltrarAudiencias(filter);
var retorno = qry.Select(x => x.ConverterParaModelo());
return(retorno.ToList());
}
}
public async Task <List <Prazo> > ListarPrazosParaAtribuir(AtribuicaoFilter filter, int domainGuid)
{
using (var dbContext = _fabricaDeContextos.CriaContextoDe <CadastroExternoContext>(TipoDeConexao.PreCadastro))
{
var qry = dbContext.Prazos
//.Include(x => x.Participantes)
//.Include(x => x.Processo)
//.Include(x => x.SubTarefas)
.Where(x => x.IdExecutor == null && x.IdPai == null)
.AsQueryable();
//qry = qry.FiltrarPrazo(filter);
return(_mapper.Map <List <Prazo> >(await qry.ToListAsync()));
}
}
public async Task <JsonReturn> ListarFuncionariosComPrazos(string startString, string endString, string assunto = "")
{
var retorno = new JsonReturn();
var filter = new AtribuicaoFilter();
if (!string.IsNullOrEmpty(startString) && !string.IsNullOrEmpty(endString))
{
filter.Start = DateTime.Parse(startString);
filter.End = DateTime.Parse(endString);
}
filter.Assunto = assunto;
try
{
userGuid = new Guid(Helpers.RetrieveUserClaimGuid(HttpContext));
int domainGuid;
if (userGuid != null)
{
domainGuid = _sessionService.ObterIdEscritorioUsuario(userGuid);
}
else
{
throw new NullReferenceException("Erro(1)");
}
if (domainGuid != null)
{
retorno.Object = await _funcionarioService.ListarFuncionariosComPrazos(new Guid(Helpers.RetrieveUserClaimGuid(HttpContext)), filter);
}
}
catch (Exception ex)
{
//loggar erro
retorno.Message = "Erro ao listar prazos";
retorno.Object = ex;
retorno.Status = System.Net.HttpStatusCode.InternalServerError;
return(retorno);
}
return(retorno);
}
public static IQueryable <Prazo> FiltrarPrazo(this IQueryable <Prazo> qry, AtribuicaoFilter filter)
{
if (filter.Cliente != null)
{
qry = qry.Where(x => x.Processo.IdCliente == filter.Cliente);
}
if (filter.Area != null)
{
qry = qry.Where(x => x.IdCategoria == filter.Area);
}
if (!string.IsNullOrWhiteSpace(filter.Assunto))
{
qry = qry.Where(x => x.Assunto.ToLower().Contains(filter.Assunto.ToLower()));
}
return(qry);
}
public static IQueryable <Audiencia> FiltrarAudiencias(this IQueryable <Audiencia> qry, AtribuicaoFilter filter)
{
if (filter.Start != null)
{
qry = qry.Where(x => x.DataAtividade >= filter.Start);
}
if (filter.End != null)
{
qry = qry.Where(x => x.DataAtividade <= filter.End);
}
if (filter.Area != null)
{
qry = qry.Where(x => x.IdCategoria == filter.Area);
}
if (!string.IsNullOrEmpty(filter.Assunto))
{
qry = qry.Where(x => x.Assunto.ToLower().Equals(filter.Assunto));
}
return(qry);
}
public async Task <List <FuncionarioViewModel> > ListarFuncionariosComAudiencias(Guid guid, AtribuicaoFilter Filter)
{
var li = await _profissionalService.ListarProfissionais(guid);
var liFuncionarios = _mapper.Map <List <FuncionarioViewModel> >(li);
var audiencias = _audienciaRepositorio.ListaAudienciasDosFuncionarios(liFuncionarios.Select(x => x.Id)).Result.ToList();
if (!string.IsNullOrEmpty(Filter.Assunto))
{
audiencias = audiencias.Where(x => x.Assunto.Contains(Filter.Assunto)).ToList();
}
//setar executor das audiências // transpor para o metodo _audienciaRepositorio.ListaAudienciasDosFuncionarios()
foreach (var i in audiencias)
{
var executor = liFuncionarios.FirstOrDefault(x => x.Id == i.IdExecutor);
i.Executor = new Executor {
Id = executor.Id, Cargo = executor.Cargo, Ativo = executor.Ativo, Atividades = executor.Atividades, Deletable = executor.Deletable, Nome = executor.Nome
};
}
try
{
liFuncionarios = RelacionarAudienciasDosFuncionarios(liFuncionarios, audiencias);
}
catch (Exception ex)
{
//loggar erro
throw ex;
}
liFuncionarios = ApplyEmployeesFilters(Filter, liFuncionarios);
return(liFuncionarios.OrderByDescending(x => x.Audiencias.Count).ToList());
}
public async Task <List <Atividade> > ObterTarefasDistribuicao(int domainGuid, AtribuicaoFilter filter)
{
var dados = await _prazoRepositorio.ListarPrazosParaAtribuir(filter, domainGuid);
var retorno = _mapper.Map <List <Atividade> >(dados);
return(retorno);
}
public async Task <List <AudienciasDateViewModel> > ObterAudienciasDistribuicao(int domainGuid, AtribuicaoFilter filter)
{
var audiencias = await _audienciaRepositorio.ListarAudienciasSemExecutor(filter, domainGuid);
var retorno = new List <AudienciasDateViewModel>();
var liAud = _mapper.Map <List <Atividade> >(audiencias);
var auds = liAud.GroupBy(x => x.DataInicio.GetValueOrDefault().Date).ToList();
AudienciasDateViewModel audiencia;
foreach (var i in auds)
{
audiencia = new AudienciasDateViewModel();
audiencia.Data = i.Key;
audiencia.Hierarquia = i.FirstOrDefault()?.Processo?.ForoHierarquia;
audiencia.Audiencias.AddRange(i);
retorno.Add(audiencia);
}
return(retorno);
}
public async Task <ProcessoAudienciaViewModel> ListarAudienciasParaDistribuicao(int IdEscritorio, Guid guid, AtribuicaoFilter searchFilter)
{
var processos = await _processoRepositorio.ListarComAudiencias(IdEscritorio);
var audiencias = new List <Audiencia>();
var comarcas = processos.Where(x => x.IdGrupoForo != null).Select(x => x.IdGrupoForo.Value).Distinct().ToList();
foreach (var processo in processos)
{
foreach (var audiencia in processo.Audiencias)
{
audiencias.Add(audiencia);
}
}
var varasAudiencias = audiencias.Where(c => c.IdForo != null).Select(v => (int)v.IdForo);
//lista profissionais(funcionarios)
var li = await _profissionalService.ListarProfissionais(guid);
var liFuncionarios = _mapper.Map <List <Domain.ViewModels.FuncionarioViewModel> >(li);
//add construtor
var procAud = new ProcessoAudienciaViewModel {
Hierarquia = new List <HierarquiaAudiencia>()
};
foreach (var audiencia in audiencias)
{
var executor = liFuncionarios.FirstOrDefault(x => x.Id == audiencia.IdExecutor);
if (executor != null)
{
audiencia.Executor = new Domain.ViewModels.Agenda.Executor {
Id = executor.Id, Cargo = executor.Cargo, Ativo = executor.Ativo, Atividades = executor.Atividades, Deletable = executor.Deletable, Nome = executor.Nome
};
}
else
{
audiencia.Executor = new Domain.ViewModels.Agenda.Executor();
}
}
////filtros de audiencias
//audiencias = ApplyAudienciasFilters(searchFilter, audiencias);
foreach (var id in comarcas)
{
var comarca = await _hierarquiaService.Obtem(guid, id, null);
var liAud = new List <Audiencia>();
foreach (var foro in comarca.Grupos)
{
var varas = comarca.Grupos.Where(x => x.Itens.Count > 0).Select(c => c.Itens);
var varasComarcas = new List <Foro>();
foreach (var vara in foro.Itens)
{
var audiencias2 = audiencias.Where(x => x.IdForo == vara.Id).ToList();
if (audiencias2.Count > 0)
{
vara.Audiencias = new List <Audiencia>(audiencias2.OrderBy(x => x.DataAtividade));
}
}
}
var HA = new HierarquiaAudiencia()
{
Comarca = comarca
};
procAud.Hierarquia.Add(HA);
}
return(procAud);
}
public async Task <List <FuncionarioViewModel> > ListarFuncionariosComPrazos(Guid guid, AtribuicaoFilter Filter)
{
var funcs = new List <Profissional>();
if (Filter.Area == null)
{
funcs = await _profissionalService.ListarProfissionais(guid);
}
else
{
funcs = await _profissionalService.ListarProfissionaisPorArea(guid, (int)Filter.Area);
foreach (var i in funcs)
{
i.IdCategoria = (int)Filter.Area;
}
}
funcs.RemoveAll(x => !x.Id.HasValue);
var funcionarios = _mapper.Map <List <FuncionarioViewModel> >(funcs);
var prazos = _prazoRepositorio.ListaPrazosDosFuncionarios(funcionarios.Select(x => x.Id)).Result.ToList();
var prazosFiltrados = ApplyPrazosFilters(Filter, prazos);
funcionarios = RelacionarPrazosDosFuncionarios(funcionarios, prazosFiltrados);
return(funcionarios.OrderByDescending(x => x.Atividades.Count).ToList());
}
