public async Task <GruposPartesListItem> ListarGruposPartesProcesso(Guid userGuid, string termo, int casoId, bool clientes, bool partes, bool profissionais)
        {
            var retorno = new GruposPartesListItem();

            var taskCliente       = new List <Cliente>();
            var taskProfissionais = new List <Profissional>();
            var taskEnvolvidos    = new List <Domain.Models.BackendModels.Parte>();

            if (clientes)
            {
                taskCliente = await _clienteService.ListarClientesPorTermo(userGuid, termo);
            }

            if (profissionais)
            {
                taskProfissionais = await _profissionalService.ListarProfissionaisPorTermo(userGuid, termo);
            }

            if (partes)
            {
                taskEnvolvidos = await _processoService.ListarEnvolvidosPorTermo(userGuid, termo);
            }

            var taskEnvolvidosBd   = _envolvimentoRepositorio.ListarEnvolvidosPorTermo(termo);
            var taskEnvolvidosCaso = ListarPolosProcesso(casoId);

            await Task.WhenAll(taskEnvolvidosBd, taskEnvolvidosCaso);

            retorno.Clientes      = (taskCliente == null) ? new List <Domain.Models.BackendModels.Cliente>() : taskCliente;;
            retorno.Profissionais = (taskProfissionais == null) ? new List <Domain.Models.BackendModels.Profissional>() : taskProfissionais;;
            retorno.Envolvidos    = (taskEnvolvidos == null) ? new List <Domain.Models.BackendModels.Parte>() : taskEnvolvidos;

            var partesBd = _mapper.Map <List <Domain.Models.BackendModels.Parte> >(taskEnvolvidosBd.Result.ToList());

            retorno.MergeEnvolvidosLocalAndServico(partesBd);
            retorno.EsconderPartesJaCadastradas(taskEnvolvidosCaso.Result);

            return(retorno);
        }
        public List <EnvolvidosViewModel> FiltrarListaEnvolvidos(bool clientes, bool profissionais, bool partes, string termo, GruposPartesListItem listaEnvolvidos)
        {
            var retornoFiltrado = new EnvolvidosPaginados();

            if (clientes)
            {
                foreach (var cliente in listaEnvolvidos.Clientes)
                {
                    var clienteEnvolvido = new EnvolvidosViewModel {
                        Id = cliente.Id.GetValueOrDefault(), Nome = cliente.Nome, Tipo = "Cliente"
                    };
                    retornoFiltrado.Envolvidos.Add(clienteEnvolvido);
                }
            }

            if (profissionais)
            {
                foreach (var profissional in listaEnvolvidos.Profissionais)
                {
                    var profissionalEnvolvido = new EnvolvidosViewModel {
                        Id = profissional.Id.GetValueOrDefault(), Nome = profissional.Nome, Tipo = "Profissional"
                    };
                    retornoFiltrado.Envolvidos.Add(profissionalEnvolvido);
                }
            }

            if (partes)
            {
                foreach (var parte in listaEnvolvidos.Envolvidos)
                {
                    var parteEnvolvida = new EnvolvidosViewModel {
                        Id = parte.IdParte, Nome = parte.Nome, Tipo = "Parte"
                    };
                    retornoFiltrado.Envolvidos.Add(parteEnvolvida);
                }
            }

            if (!string.IsNullOrWhiteSpace(termo))
            {
                retornoFiltrado.Envolvidos = retornoFiltrado.Envolvidos.FindAll(x => x.Nome.Trim().ToLower().Contains(termo.Trim().ToLower()));
            }

            return(retornoFiltrado.Envolvidos);
        }