using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using Gestor.Application.Actions;
using Gestor.Application.Helpers;
using Gestor.Application.Servicos.Ferramentas;
using Gestor.Application.ViewModels.Generic;
using Gestor.Common.Validation;
using Gestor.Model.Common;
using Gestor.Model.Domain.Generic;
using Gestor.Model.Domain.Relatorios;
using Gestor.Model.Domain.Relatorios.ApolicePendente;
using Gestor.Model.Domain.Relatorios.Auditoria;
using Gestor.Model.Domain.Relatorios.ClientesAtivosInativos;
using Gestor.Model.Domain.Relatorios.Comissao;
using Gestor.Model.Domain.Relatorios.ExtratoBaixado;
using Gestor.Model.Domain.Relatorios.FaturaPendente;
using Gestor.Model.Domain.Relatorios.Fechamento;
using Gestor.Model.Domain.Relatorios.Licenciamento;
using Gestor.Model.Domain.Relatorios.LogsEnvio;
using Gestor.Model.Domain.Relatorios.MetaSeguradora;
using Gestor.Model.Domain.Relatorios.MetaVendedor;
using Gestor.Model.Domain.Relatorios.NotaFiscal;
using Gestor.Model.Domain.Relatorios.Pendente;
using Gestor.Model.Domain.Relatorios.Placa;
using Gestor.Model.Domain.Relatorios.PrevisaoPagamentoComissao;
using Gestor.Model.Domain.Relatorios.Producao;
using Gestor.Model.Domain.Relatorios.Renovacao;
using Gestor.Model.Domain.Relatorios.Sinistro;
using Gestor.Model.Domain.Relatorios.Tarefa;
using Gestor.Model.Domain.Seguros;

namespace Gestor.Application.ViewModels.Drawer;

public class PermissaoUsuarioViewModel : BaseSegurosViewModel
{
	private readonly UsuarioServico _servicoUsuario;

	private Usuario _selectedUsuario;

	private bool _expandedBis;

	private bool _expandedSeguros;

	private bool _expandedRelatorios;

	private bool _expandedCampos;

	private bool _expandedTotalizacoes;

	private bool _expandedFinanceiros;

	private bool _expandedFerramentas;

	private bool _expandedAjudas;

	private ObservableCollection<PermissaoUsuario> _seguros;

	private ObservableCollection<PermissaoUsuario> _ferramentas;

	private ObservableCollection<PermissaoArquivoDigital> _arquivosDigitais;

	private bool _enableAlterarPermiss = true;

	private ObservableCollection<RestricaoUsuario> _restricoesBisFiltradas;

	private ObservableCollection<RestricaoUsuario> _restricoesSegurosFiltradas;

	private ObservableCollection<RestricaoUsuario> _restricoesRelatoriosFiltrados;

	private ObservableCollection<RestricaoUsuario> _restricoesTotalizacoesRelatoriosFiltrados;

	private ObservableCollection<RestricaoUsuarioCamposRelatorios> _restricoesCamposRelatoriosFiltrados;

	private ObservableCollection<RestricaoUsuario> _restricoesFinanceirosFiltradas;

	private ObservableCollection<RestricaoUsuario> _restricoesFerramentasFiltradas;

	private ObservableCollection<RestricaoUsuario> _restricoesAjudasFiltrados;

	private List<RestricaoUsuario> _restricoesBis;

	private List<RestricaoUsuario> _restricoesSeguros;

	private List<RestricaoUsuario> _restricoesRelatorios;

	private List<RestricaoUsuario> _restricoesTotalizacoesRelatorios;

	private List<RestricaoUsuarioCamposRelatorios> _restricoesCamposRelatorios;

	private List<RestricaoUsuario> _restricoesFinanceiros;

	private List<RestricaoUsuario> _restricoesFerramentas;

	private List<RestricaoUsuario> _restricoesAjudas;

	private Visibility _restricoesBisVisibility;

	private Visibility _restricoesSegurosVisibility;

	private Visibility _restricoesRelatoriosVisibility;

	private Visibility _restricoesTotalizacoesRelatoriosVisibility;

	private Visibility _restricoesCamposRelatoriosVisibility;

	private Visibility _restricoesFinanceirosVisibility;

	private Visibility _restricoesFerramentasVisibility;

	private Visibility _restricoesAjudasVisibility;

	private List<PermissaoAggilizador> _permissaoAggilizador;

	private PermissaoAggilizador _selectedPermissao;

	private bool _admUsuario;

	private bool _importarEnabled;

	private bool _carregando;

	private bool _ativarDesativarPermissoesBool = true;

	private bool _ativarDesativarRestricoesBool = true;

	public Usuario SelectedUsuario
	{
		get
		{
			return _selectedUsuario;
		}
		set
		{
			_selectedUsuario = value;
			OnPropertyChanged("SelectedUsuario");
		}
	}

	public bool Carregado { get; set; }

	public bool ExpandedBis
	{
		get
		{
			return _expandedBis;
		}
		set
		{
			_expandedBis = value;
			OnPropertyChanged("ExpandedBis");
		}
	}

	public bool ExpandedSeguros
	{
		get
		{
			return _expandedSeguros;
		}
		set
		{
			_expandedSeguros = value;
			OnPropertyChanged("ExpandedSeguros");
		}
	}

	public bool ExpandedRelatorios
	{
		get
		{
			return _expandedRelatorios;
		}
		set
		{
			_expandedRelatorios = value;
			OnPropertyChanged("ExpandedRelatorios");
		}
	}

	public bool ExpandedCampos
	{
		get
		{
			return _expandedCampos;
		}
		set
		{
			_expandedCampos = value;
			OnPropertyChanged("ExpandedCampos");
		}
	}

	public bool ExpandedTotalizacoes
	{
		get
		{
			return _expandedTotalizacoes;
		}
		set
		{
			_expandedTotalizacoes = value;
			OnPropertyChanged("ExpandedTotalizacoes");
		}
	}

	public bool ExpandedFinanceiros
	{
		get
		{
			return _expandedFinanceiros;
		}
		set
		{
			_expandedFinanceiros = value;
			OnPropertyChanged("ExpandedFinanceiros");
		}
	}

	public bool ExpandedFerramentas
	{
		get
		{
			return _expandedFerramentas;
		}
		set
		{
			_expandedFerramentas = value;
			OnPropertyChanged("ExpandedFerramentas");
		}
	}

	public bool ExpandedAjudas
	{
		get
		{
			return _expandedAjudas;
		}
		set
		{
			_expandedAjudas = value;
			OnPropertyChanged("ExpandedAjudas");
		}
	}

	public ObservableCollection<PermissaoUsuario> Seguros
	{
		get
		{
			return _seguros;
		}
		set
		{
			_seguros = value;
			OnPropertyChanged("Seguros");
			if (value != null && Ferramentas != null && value.All((PermissaoUsuario x) => ((int)x.Tela == 21 && x.Consultar) || ((int)x.Tela == 5 && x.Alterar && x.Incluir && x.Excluir) || ((int)x.Tela != 21 && (int)x.Tela != 5 && x.Consultar && x.Alterar && x.Incluir && x.Excluir)) && Ferramentas.All((PermissaoUsuario x) => ((int)x.Tela == 18 && x.Consultar && x.Alterar) || ((int)x.Tela == 10 && x.Consultar && x.Alterar && x.Incluir) || ((int)x.Tela == 12 && x.Consultar && x.Alterar) || ((int)x.Tela == 13 && x.Consultar && x.Alterar && x.Incluir) || ((int)x.Tela != 18 && (int)x.Tela != 10 && (int)x.Tela != 12 && (int)x.Tela != 13 && x.Consultar && x.Alterar && x.Incluir && x.Excluir)))
			{
				AtivarDesativarPermissoesBool = false;
			}
			Gestor.Application.Actions.Actions.OcultarTogglesSeguros();
		}
	}

	public ObservableCollection<PermissaoUsuario> Ferramentas
	{
		get
		{
			return _ferramentas;
		}
		set
		{
			_ferramentas = value;
			OnPropertyChanged("Ferramentas");
			if (value != null && Seguros != null && value.All((PermissaoUsuario x) => ((int)x.Tela == 18 && x.Consultar && x.Alterar) || ((int)x.Tela == 10 && x.Consultar && x.Alterar && x.Incluir) || ((int)x.Tela == 12 && x.Consultar && x.Alterar) || ((int)x.Tela == 13 && x.Consultar && x.Alterar && x.Incluir) || ((int)x.Tela != 18 && (int)x.Tela != 10 && (int)x.Tela != 12 && (int)x.Tela != 13 && x.Consultar && x.Alterar && x.Incluir && x.Excluir)) && Seguros.All((PermissaoUsuario x) => ((int)x.Tela == 21 && x.Consultar) || ((int)x.Tela == 5 && x.Alterar && x.Incluir && x.Excluir) || ((int)x.Tela != 21 && (int)x.Tela != 5 && x.Consultar && x.Alterar && x.Incluir && x.Excluir)))
			{
				AtivarDesativarPermissoesBool = false;
			}
			Gestor.Application.Actions.Actions.OcultarTogglesFerramentas();
		}
	}

	public ObservableCollection<PermissaoArquivoDigital> ArquivosDigitais
	{
		get
		{
			return _arquivosDigitais;
		}
		set
		{
			_arquivosDigitais = value;
			OnPropertyChanged("ArquivosDigitais");
			Gestor.Application.Actions.Actions.OcultarTogglesArquivoDigital();
		}
	}

	public bool EnableAlterarPermiss
	{
		get
		{
			return _enableAlterarPermiss;
		}
		set
		{
			_enableAlterarPermiss = value;
			OnPropertyChanged("EnableAlterarPermiss");
		}
	}

	public ObservableCollection<RestricaoUsuario> RestricoesBisFiltradas
	{
		get
		{
			return _restricoesBisFiltradas;
		}
		set
		{
			RestricoesBisVisibility = (Visibility)((value == null || value.Count <= 0) ? 2 : 0);
			_restricoesBisFiltradas = new ObservableCollection<RestricaoUsuario>(from x in value.ToList()
				orderby ValidationHelper.GetDescription((Enum)(object)x.Tipo)
				select x);
			OnPropertyChanged("RestricoesBisFiltradas");
			AtivarDesativarRestricoes();
		}
	}

	public ObservableCollection<RestricaoUsuario> RestricoesSegurosFiltradas
	{
		get
		{
			return _restricoesSegurosFiltradas;
		}
		set
		{
			RestricoesSegurosVisibility = (Visibility)((value == null || value.Count <= 0) ? 2 : 0);
			_restricoesSegurosFiltradas = new ObservableCollection<RestricaoUsuario>(from x in value.ToList()
				orderby ValidationHelper.GetDescription((Enum)(object)x.Tipo)
				select x);
			OnPropertyChanged("RestricoesSegurosFiltradas");
			AtivarDesativarRestricoes();
		}
	}

	public ObservableCollection<RestricaoUsuario> RestricoesRelatoriosFiltrados
	{
		get
		{
			return _restricoesRelatoriosFiltrados;
		}
		set
		{
			RestricoesRelatoriosVisibility = (Visibility)((value == null || value.Count <= 0) ? 2 : 0);
			_restricoesRelatoriosFiltrados = new ObservableCollection<RestricaoUsuario>(from x in value.ToList()
				orderby ValidationHelper.GetDescription((Enum)(object)x.Tipo)
				select x);
			OnPropertyChanged("RestricoesRelatoriosFiltrados");
			AtivarDesativarRestricoes();
		}
	}

	public ObservableCollection<RestricaoUsuario> RestricoesTotalizacoesRelatoriosFiltrados
	{
		get
		{
			return _restricoesTotalizacoesRelatoriosFiltrados;
		}
		set
		{
			RestricoesTotalizacoesRelatoriosVisibility = (Visibility)((value == null || value.Count <= 0) ? 2 : 0);
			_restricoesTotalizacoesRelatoriosFiltrados = new ObservableCollection<RestricaoUsuario>(from x in value.ToList()
				orderby ValidationHelper.GetDescription((Enum)(object)x.Tipo)
				select x);
			OnPropertyChanged("RestricoesTotalizacoesRelatoriosFiltrados");
			AtivarDesativarRestricoes();
		}
	}

	public ObservableCollection<RestricaoUsuarioCamposRelatorios> RestricoesCamposRelatoriosFiltrados
	{
		get
		{
			return _restricoesCamposRelatoriosFiltrados;
		}
		set
		{
			RestricoesCamposRelatoriosVisibility = (Visibility)((value == null || value.Count <= 0) ? 2 : 0);
			_restricoesCamposRelatoriosFiltrados = new ObservableCollection<RestricaoUsuarioCamposRelatorios>(from x in value.ToList()
				orderby x.Relatorio, x.Campo
				select x);
			OnPropertyChanged("RestricoesCamposRelatoriosFiltrados");
			AtivarDesativarRestricoes();
		}
	}

	public ObservableCollection<RestricaoUsuario> RestricoesFinanceirosFiltradas
	{
		get
		{
			return _restricoesFinanceirosFiltradas;
		}
		set
		{
			RestricoesFinanceirosVisibility = (Visibility)((value == null || value.Count <= 0) ? 2 : 0);
			_restricoesFinanceirosFiltradas = new ObservableCollection<RestricaoUsuario>(from x in value.ToList()
				orderby ValidationHelper.GetDescription((Enum)(object)x.Tipo)
				select x);
			OnPropertyChanged("RestricoesFinanceirosFiltradas");
			AtivarDesativarRestricoes();
		}
	}

	public ObservableCollection<RestricaoUsuario> RestricoesFerramentasFiltradas
	{
		get
		{
			return _restricoesFerramentasFiltradas;
		}
		set
		{
			RestricoesFerramentasVisibility = (Visibility)((value == null || value.Count <= 0) ? 2 : 0);
			_restricoesFerramentasFiltradas = new ObservableCollection<RestricaoUsuario>(from x in value.ToList()
				orderby ValidationHelper.GetDescription((Enum)(object)x.Tipo)
				select x);
			OnPropertyChanged("RestricoesFerramentasFiltradas");
			AtivarDesativarRestricoes();
		}
	}

	public ObservableCollection<RestricaoUsuario> RestricoesAjudasFiltrados
	{
		get
		{
			return _restricoesAjudasFiltrados;
		}
		set
		{
			RestricoesAjudasVisibility = (Visibility)((value == null || value.Count <= 0) ? 2 : 0);
			_restricoesAjudasFiltrados = new ObservableCollection<RestricaoUsuario>(from x in value.ToList()
				orderby ValidationHelper.GetDescription((Enum)(object)x.Tipo)
				select x);
			OnPropertyChanged("RestricoesAjudasFiltrados");
			AtivarDesativarRestricoes();
		}
	}

	public List<RestricaoUsuario> RestricoesBis
	{
		get
		{
			return _restricoesBis;
		}
		set
		{
			_restricoesBis = value;
			OnPropertyChanged("RestricoesBis");
		}
	}

	public List<RestricaoUsuario> RestricoesSeguros
	{
		get
		{
			return _restricoesSeguros;
		}
		set
		{
			_restricoesSeguros = value;
			OnPropertyChanged("RestricoesSeguros");
		}
	}

	public List<RestricaoUsuario> RestricoesRelatorios
	{
		get
		{
			return _restricoesRelatorios;
		}
		set
		{
			_restricoesRelatorios = value;
			OnPropertyChanged("RestricoesRelatorios");
		}
	}

	public List<RestricaoUsuario> RestricoesTotalizacoesRelatorios
	{
		get
		{
			return _restricoesTotalizacoesRelatorios;
		}
		set
		{
			_restricoesTotalizacoesRelatorios = value;
			OnPropertyChanged("RestricoesTotalizacoesRelatorios");
		}
	}

	public List<RestricaoUsuarioCamposRelatorios> RestricoesCamposRelatorios
	{
		get
		{
			return _restricoesCamposRelatorios;
		}
		set
		{
			_restricoesCamposRelatorios = value;
			OnPropertyChanged("RestricoesCamposRelatorios");
		}
	}

	public List<RestricaoUsuario> RestricoesFinanceiros
	{
		get
		{
			return _restricoesFinanceiros;
		}
		set
		{
			_restricoesFinanceiros = value;
			OnPropertyChanged("RestricoesFinanceiros");
		}
	}

	public List<RestricaoUsuario> RestricoesFerramentas
	{
		get
		{
			return _restricoesFerramentas;
		}
		set
		{
			_restricoesFerramentas = value;
			OnPropertyChanged("RestricoesFerramentas");
		}
	}

	public List<RestricaoUsuario> RestricoesAjudas
	{
		get
		{
			return _restricoesAjudas;
		}
		set
		{
			_restricoesAjudas = value;
			OnPropertyChanged("RestricoesAjudas");
		}
	}

	public Visibility RestricoesBisVisibility
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _restricoesBisVisibility;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_restricoesBisVisibility = value;
			OnPropertyChanged("RestricoesBisVisibility");
		}
	}

	public Visibility RestricoesSegurosVisibility
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _restricoesSegurosVisibility;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_restricoesSegurosVisibility = value;
			OnPropertyChanged("RestricoesSegurosVisibility");
		}
	}

	public Visibility RestricoesRelatoriosVisibility
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _restricoesRelatoriosVisibility;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_restricoesRelatoriosVisibility = value;
			OnPropertyChanged("RestricoesRelatoriosVisibility");
		}
	}

	public Visibility RestricoesTotalizacoesRelatoriosVisibility
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _restricoesTotalizacoesRelatoriosVisibility;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_restricoesTotalizacoesRelatoriosVisibility = value;
			OnPropertyChanged("RestricoesTotalizacoesRelatoriosVisibility");
		}
	}

	public Visibility RestricoesCamposRelatoriosVisibility
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _restricoesCamposRelatoriosVisibility;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_restricoesCamposRelatoriosVisibility = value;
			OnPropertyChanged("RestricoesCamposRelatoriosVisibility");
		}
	}

	public Visibility RestricoesFinanceirosVisibility
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _restricoesFinanceirosVisibility;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_restricoesFinanceirosVisibility = value;
			OnPropertyChanged("RestricoesFinanceirosVisibility");
		}
	}

	public Visibility RestricoesFerramentasVisibility
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _restricoesFerramentasVisibility;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_restricoesFerramentasVisibility = value;
			OnPropertyChanged("RestricoesFerramentasVisibility");
		}
	}

	public Visibility RestricoesAjudasVisibility
	{
		get
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _restricoesAjudasVisibility;
		}
		set
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_restricoesAjudasVisibility = value;
			OnPropertyChanged("RestricoesAjudasVisibility");
		}
	}

	public List<PermissaoAggilizador> PermissaoAggilizador
	{
		get
		{
			return _permissaoAggilizador;
		}
		set
		{
			_permissaoAggilizador = value;
			OnPropertyChanged("PermissaoAggilizador");
		}
	}

	public PermissaoAggilizador SelectedPermissao
	{
		get
		{
			return _selectedPermissao;
		}
		set
		{
			_selectedPermissao = value;
			OnPropertyChanged("SelectedPermissao");
		}
	}

	public bool AdmUsuario
	{
		get
		{
			return _admUsuario;
		}
		set
		{
			_admUsuario = value;
			ImportarEnabled = !value;
			SelectedUsuario.Administrador = value;
			if (value && !Carregando)
			{
				AtivarDesativarPermissoes(permiss: true);
				AtivarDesativarRestricoes(restricao: false);
			}
			OnPropertyChanged("AdmUsuario");
		}
	}

	public bool ImportarEnabled
	{
		get
		{
			return _importarEnabled;
		}
		set
		{
			_importarEnabled = value;
			OnPropertyChanged("ImportarEnabled");
		}
	}

	public bool Carregando
	{
		get
		{
			return _carregando;
		}
		set
		{
			_carregando = value;
			base.IsEnabled = !value;
			base.EnableMenu = !value;
			OnPropertyChanged("Carregando");
		}
	}

	public bool AtivarDesativarPermissoesBool
	{
		get
		{
			return _ativarDesativarPermissoesBool;
		}
		set
		{
			_ativarDesativarPermissoesBool = value;
			OnPropertyChanged("AtivarDesativarPermissoesBool");
		}
	}

	public bool AtivarDesativarRestricoesBool
	{
		get
		{
			return _ativarDesativarRestricoesBool;
		}
		set
		{
			_ativarDesativarRestricoesBool = value;
			OnPropertyChanged("AtivarDesativarRestricoesBool");
		}
	}

	public PermissaoUsuarioViewModel(Usuario usuario)
	{
		SelectedUsuario = usuario;
		_servicoUsuario = new UsuarioServico();
		CarregarModulos(usuario);
		EnableAlterarPermiss = ((DomainBase)Recursos.Usuario).Id > 0;
	}

	private async void CarregarModulos(Usuario usuario)
	{
		await Modulos(usuario);
		Carregado = true;
	}

	private async Task Modulos(Usuario usuario)
	{
		Carregando = true;
		usuario = await _servicoUsuario.BuscarUsuarioPorId(((DomainBase)usuario).Id);
		Seguros = new ObservableCollection<PermissaoUsuario>(await GetPermissoes(usuario, "seguros"));
		Ferramentas = new ObservableCollection<PermissaoUsuario>(await GetPermissoes(usuario, "ferramentas"));
		ArquivosDigitais = new ObservableCollection<PermissaoArquivoDigital>(await GetPermissoesArquivoDigital(usuario));
		PermissaoAggilizador = new List<PermissaoAggilizador>(await _servicoUsuario.BuscarPermissaoAggilizador());
		RestricoesBis = await GetRestricoes(usuario, "b.i.");
		RestricoesBisFiltradas = new ObservableCollection<RestricaoUsuario>(RestricoesBis);
		RestricoesSeguros = await GetRestricoes(usuario, "seguros");
		RestricoesSegurosFiltradas = new ObservableCollection<RestricaoUsuario>(RestricoesSeguros);
		RestricoesRelatorios = await GetRestricoes(usuario, "relatorios");
		RestricoesRelatoriosFiltrados = new ObservableCollection<RestricaoUsuario>(RestricoesRelatorios);
		RestricoesFinanceiros = await GetRestricoes(usuario, "financeiro");
		RestricoesFinanceirosFiltradas = new ObservableCollection<RestricaoUsuario>(RestricoesFinanceiros);
		RestricoesFerramentas = await GetRestricoes(usuario, "ferramentas");
		RestricoesFerramentasFiltradas = new ObservableCollection<RestricaoUsuario>(RestricoesFerramentas);
		RestricoesAjudas = await GetRestricoes(usuario, "ajuda");
		RestricoesAjudasFiltrados = new ObservableCollection<RestricaoUsuario>(RestricoesAjudas);
		RestricoesTotalizacoesRelatorios = await GetRestricoes(usuario, "totalizacoesRelatorios");
		RestricoesTotalizacoesRelatoriosFiltrados = new ObservableCollection<RestricaoUsuario>(RestricoesTotalizacoesRelatorios);
		RestricoesCamposRelatorios = await GetRestricoesCamposRelatorios(usuario);
		RestricoesCamposRelatoriosFiltrados = new ObservableCollection<RestricaoUsuarioCamposRelatorios>(RestricoesCamposRelatorios);
		Carregando = false;
		AdmUsuario = usuario.Administrador;
		SelectedPermissao = ((!usuario.PermissaoAggilizador.HasValue) ? ((IEnumerable<PermissaoAggilizador>)PermissaoAggilizador).FirstOrDefault((Func<PermissaoAggilizador, bool>)((PermissaoAggilizador x) => ((DomainBase)x).Id == 2)) : ((IEnumerable<PermissaoAggilizador>)PermissaoAggilizador).FirstOrDefault((Func<PermissaoAggilizador, bool>)((PermissaoAggilizador x) => ((DomainBase)x).Id == usuario.PermissaoAggilizador)));
	}

	private async Task<List<PermissaoArquivoDigital>> GetPermissoesArquivoDigital(Usuario usuario)
	{
		List<PermissaoArquivoDigital> list = new List<PermissaoArquivoDigital>();
		List<string> telas = (from TipoArquivoDigital v in Enum.GetValues(typeof(TipoArquivoDigital))
			select ((object)(TipoArquivoDigital)(ref v)).ToString() into x
			orderby x
			select x).ToList();
		List<PermissaoArquivoDigital> permissoes = await ServicoPermissArquivoDigital.PermissArquivoDigital(usuario);
		telas.ForEach(delegate(string x)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			TipoArquivoDigital tela = (TipoArquivoDigital)Enum.Parse(typeof(TipoArquivoDigital), x);
			long id = 0L;
			bool consultar = true;
			bool incluir = true;
			bool excluir = true;
			if (permissoes.Count > 0 && permissoes.Any((PermissaoArquivoDigital y) => y.Tela == tela))
			{
				id = ((DomainBase)permissoes.First((PermissaoArquivoDigital y) => y.Tela == tela)).Id;
				consultar = permissoes.First((PermissaoArquivoDigital y) => y.Tela == tela).Consultar;
				incluir = permissoes.First((PermissaoArquivoDigital y) => y.Tela == tela).Incluir;
				excluir = permissoes.First((PermissaoArquivoDigital y) => y.Tela == tela).Excluir;
			}
			PermissaoArquivoDigital item = new PermissaoArquivoDigital
			{
				Id = id,
				Tela = tela,
				Consultar = consultar,
				Incluir = incluir,
				Excluir = excluir
			};
			list.Add(item);
		});
		return list;
	}

	private async Task<List<PermissaoUsuario>> GetPermissoes(Usuario usuario, string modulo)
	{
		List<PermissaoUsuario> list = new List<PermissaoUsuario>();
		List<string> telas = (from TipoTela v in Enum.GetValues(typeof(TipoTela))
			select ((object)(TipoTela)(ref v)).ToString() into x
			orderby x
			select x).ToList();
		List<PermissaoUsuario> permissoes = await ServicoPermissUsuario.PermissUsuario(usuario);
		telas.ForEach(delegate(string x)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			TipoTela tela = (TipoTela)Enum.Parse(typeof(TipoTela), x);
			if (string.Equals(ValidationHelper.GetCategory((Enum)(object)tela), modulo, StringComparison.CurrentCultureIgnoreCase))
			{
				long id = 0L;
				bool consultar = true;
				bool incluir = true;
				bool alterar = true;
				bool excluir = true;
				if (permissoes.Count > 0 && permissoes.Any((PermissaoUsuario y) => y.Tela == tela))
				{
					id = ((DomainBase)permissoes.First((PermissaoUsuario y) => y.Tela == tela)).Id;
					consultar = permissoes.First((PermissaoUsuario y) => y.Tela == tela).Consultar;
					incluir = permissoes.First((PermissaoUsuario y) => y.Tela == tela).Incluir;
					alterar = permissoes.First((PermissaoUsuario y) => y.Tela == tela).Alterar;
					excluir = permissoes.First((PermissaoUsuario y) => y.Tela == tela).Excluir;
				}
				PermissaoUsuario item = new PermissaoUsuario
				{
					Id = id,
					Tela = tela,
					Consultar = consultar,
					Incluir = incluir,
					Alterar = alterar,
					Excluir = excluir
				};
				list.Add(item);
			}
		});
		return list;
	}

	private async Task<List<RestricaoUsuario>> GetRestricoes(Usuario usuario, string modulo)
	{
		List<RestricaoUsuario> list = new List<RestricaoUsuario>();
		List<string> tipos = (from TipoRestricao v in Enum.GetValues(typeof(TipoRestricao))
			select ((object)(TipoRestricao)(ref v)).ToString() into x
			orderby x
			select x).ToList();
		List<RestricaoUsuario> restricoesUsuario = await ServicoRestriUsuario.BuscarRestricoes(((DomainBase)usuario).Id);
		tipos.ForEach(delegate(string x)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			TipoRestricao tipo = (TipoRestricao)Enum.Parse(typeof(TipoRestricao), x);
			if (string.Equals(ValidationHelper.GetCategory((Enum)(object)tipo), modulo, StringComparison.CurrentCultureIgnoreCase))
			{
				string help = ValidationHelper.GetHelp((Enum)(object)tipo);
				long id = 0L;
				bool restricao = false;
				if (restricoesUsuario.Count > 0 && restricoesUsuario.Any((RestricaoUsuario y) => y.Tipo == tipo))
				{
					id = ((DomainBase)restricoesUsuario.First((RestricaoUsuario y) => y.Tipo == tipo)).Id;
					restricao = restricoesUsuario.First((RestricaoUsuario y) => y.Tipo == tipo).Restricao;
				}
				RestricaoUsuario item = new RestricaoUsuario
				{
					Id = id,
					Tipo = tipo,
					Restricao = restricao,
					Ajuda = help
				};
				list.Add(item);
			}
		});
		return list;
	}

	private async Task<List<RestricaoUsuarioCamposRelatorios>> GetRestricoesCamposRelatorios(Usuario usuario)
	{
		List<RestricaoUsuarioCamposRelatorios> list = new List<RestricaoUsuarioCamposRelatorios>();
		List<ParametrosRelatorio> parametros = new List<ParametrosRelatorio>();
		foreach (Relatorio item2 in Enum.GetValues(typeof(Relatorio)).Cast<Relatorio>())
		{
			switch ((int)item2)
			{
			case 0:
			case 1:
				parametros.AddRange(Funcoes.ColunasRelatorio<ClientesAtivosInativos>(item2, new List<ParametrosRelatorio>()));
				break;
			case 2:
				parametros.AddRange(Funcoes.ColunasRelatorio<Producao>(item2, new List<ParametrosRelatorio>()));
				break;
			case 3:
				parametros.AddRange(Funcoes.ColunasRelatorio<ApolicePendente>(item2, new List<ParametrosRelatorio>()));
				break;
			case 18:
				parametros.AddRange(Funcoes.ColunasRelatorio<Tarefa>(item2, new List<ParametrosRelatorio>()));
				break;
			case 4:
				parametros.AddRange(Funcoes.ColunasRelatorio<Renovacao>(item2, new List<ParametrosRelatorio>()));
				break;
			case 5:
				parametros.AddRange(Funcoes.ColunasRelatorio<Comissao>(item2, new List<ParametrosRelatorio>()));
				break;
			case 6:
			case 16:
				parametros.AddRange(Funcoes.ColunasRelatorio<Pendente>(item2, new List<ParametrosRelatorio>()));
				break;
			case 9:
			case 10:
				parametros.AddRange(Funcoes.ColunasRelatorio<Sinistro>(item2, new List<ParametrosRelatorio>()));
				break;
			case 23:
				parametros.AddRange(Funcoes.ColunasRelatorio<LogsEnvio>(item2, new List<ParametrosRelatorio>()));
				break;
			case 8:
				parametros.AddRange(Funcoes.ColunasRelatorio<Auditoria>(item2, new List<ParametrosRelatorio>()));
				break;
			case 13:
				parametros.AddRange(Funcoes.ColunasRelatorio<ExtratoBaixadoRelatorio>(item2, new List<ParametrosRelatorio>()));
				break;
			case 12:
				parametros.AddRange(Funcoes.ColunasRelatorio<FaturaPendente>(item2, new List<ParametrosRelatorio>()));
				break;
			case 14:
				parametros.AddRange(Funcoes.ColunasRelatorio<MetaSeguradoraRelatorio>(item2, new List<ParametrosRelatorio>()));
				break;
			case 15:
				parametros.AddRange(Funcoes.ColunasRelatorio<MetaVendedorRelatorio>(item2, new List<ParametrosRelatorio>()));
				break;
			case 11:
				parametros.AddRange(Funcoes.ColunasRelatorio<Fechamento>(item2, new List<ParametrosRelatorio>()));
				break;
			case 17:
				parametros.AddRange(Funcoes.ColunasRelatorio<Licenciamento>(item2, new List<ParametrosRelatorio>()));
				break;
			case 27:
				parametros.AddRange(Funcoes.ColunasRelatorio<Placas>(item2, new List<ParametrosRelatorio>()));
				break;
			case 7:
				parametros.AddRange(Funcoes.ColunasRelatorio<DadosRelatorio>(item2, new List<ParametrosRelatorio>()));
				break;
			case 19:
				parametros.AddRange(Funcoes.ColunasRelatorio<NotaFiscalRelatorio>(item2, new List<ParametrosRelatorio>()));
				break;
			case 20:
				parametros.AddRange(Funcoes.ColunasRelatorio<PrevisaoPagamento>(item2, new List<ParametrosRelatorio>()));
				break;
			}
		}
		List<RestricaoUsuarioCamposRelatorios> restricoesUsuario = await ServicoRestriUsuario.BuscarRestricoesCamposRelatorios(((DomainBase)usuario).Id);
		parametros.ForEach(delegate(ParametrosRelatorio x)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			long id = 0L;
			bool restricao = false;
			if (restricoesUsuario.Count > 0 && restricoesUsuario.Any((RestricaoUsuarioCamposRelatorios y) => y.Campo == x.Header && y.Relatorio == x.Relatorio))
			{
				id = ((DomainBase)restricoesUsuario.First((RestricaoUsuarioCamposRelatorios y) => y.Campo == x.Header && y.Relatorio == x.Relatorio)).Id;
				restricao = restricoesUsuario.First((RestricaoUsuarioCamposRelatorios y) => y.Campo == x.Header && y.Relatorio == x.Relatorio).Restricao;
			}
			RestricaoUsuarioCamposRelatorios item = new RestricaoUsuarioCamposRelatorios
			{
				Id = id,
				Campo = x.Header,
				Relatorio = x.Relatorio,
				Restricao = restricao
			};
			list.Add(item);
		});
		return list;
	}

	public async Task<bool> Salvar(long? idUsuario = null, bool registrar = true)
	{
		PermissaoUsuario obj = ServicoPermissUsuario.BuscarPermissao(Recursos.Usuario, (TipoTela)43);
		if (obj != null && !obj.Alterar && !Recursos.Usuario.Administrador)
		{
			await ShowMessage("VOCÊ NÃO TEM PERMISSÃO PARA ALTERAR PERMISSÕES!");
			return false;
		}
		Usuario usuario = await _servicoUsuario.BuscarUsuarioPorId(idUsuario ?? ((DomainBase)_selectedUsuario).Id);
		List<PermissaoUsuario> prevPer = new List<PermissaoUsuario>();
		List<PermissaoUsuario> list = prevPer;
		list.AddRange(await GetPermissoes(usuario, "seguros"));
		list = prevPer;
		list.AddRange(await GetPermissoes(usuario, "ferramentas"));
		List<PermissaoArquivoDigital> prevPerArquivoDigital = new List<PermissaoArquivoDigital>();
		List<PermissaoArquivoDigital> list2 = prevPerArquivoDigital;
		list2.AddRange(await GetPermissoesArquivoDigital(usuario));
		List<PermissaoArquivoDigital> permissao = ((IEnumerable<PermissaoArquivoDigital>)ArquivosDigitais).Select((Func<PermissaoArquivoDigital, PermissaoArquivoDigital>)((PermissaoArquivoDigital x) => new PermissaoArquivoDigital
		{
			Id = ((prevPerArquivoDigital.Count == 0) ? 0 : ((DomainBase)prevPerArquivoDigital.First((PermissaoArquivoDigital y) => y.Tela == x.Tela)).Id),
			Tela = x.Tela,
			Consultar = x.Consultar,
			Incluir = x.Incluir,
			Excluir = x.Excluir,
			Usuario = usuario
		})).ToList();
		List<PermissaoUsuario> permissoes = new List<PermissaoUsuario>();
		List<PermissaoUsuario> collection = ((IEnumerable<PermissaoUsuario>)Seguros).Select((Func<PermissaoUsuario, PermissaoUsuario>)((PermissaoUsuario x) => new PermissaoUsuario
		{
			Id = ((prevPer.Count == 0) ? 0 : ((DomainBase)prevPer.First((PermissaoUsuario y) => y.Tela == x.Tela)).Id),
			Tela = x.Tela,
			Consultar = x.Consultar,
			Incluir = x.Incluir,
			Alterar = x.Alterar,
			Excluir = x.Excluir,
			Usuario = usuario
		})).ToList();
		permissoes.AddRange(collection);
		collection = ((IEnumerable<PermissaoUsuario>)Ferramentas).Select((Func<PermissaoUsuario, PermissaoUsuario>)((PermissaoUsuario x) => new PermissaoUsuario
		{
			Id = ((prevPer.Count == 0) ? 0 : ((DomainBase)prevPer.First((PermissaoUsuario y) => y.Tela == x.Tela)).Id),
			Tela = x.Tela,
			Consultar = x.Consultar,
			Incluir = x.Incluir,
			Alterar = x.Alterar,
			Excluir = x.Excluir,
			Usuario = usuario
		})).ToList();
		permissoes.AddRange(collection);
		Usuario obj2 = usuario;
		PermissaoAggilizador selectedPermissao = SelectedPermissao;
		obj2.PermissaoAggilizador = ((selectedPermissao != null) ? ((DomainBase)selectedPermissao).Id : 0);
		usuario.Administrador = AdmUsuario;
		await ServicoPermissArquivoDigital.SavePermiss(permissao, prevPerArquivoDigital);
		if (!ServicoPermissArquivoDigital.Sucesso)
		{
			return false;
		}
		await ServicoPermissUsuario.SavePermiss(permissoes, prevPer);
		if (!ServicoPermissUsuario.Sucesso)
		{
			return false;
		}
		await _servicoUsuario.Save(usuario);
		if (!_servicoUsuario.Sucesso)
		{
			return false;
		}
		if (((DomainBase)Recursos.Usuario).Id == ((DomainBase)_selectedUsuario).Id)
		{
			Recursos.Usuario = usuario;
		}
		List<RestricaoUsuario> prevRes = new List<RestricaoUsuario>();
		List<RestricaoUsuario> list3 = prevRes;
		list3.AddRange(await GetRestricoes(usuario, "b.i."));
		list3 = prevRes;
		list3.AddRange(await GetRestricoes(usuario, "seguros"));
		list3 = prevRes;
		list3.AddRange(await GetRestricoes(usuario, "relatorios"));
		list3 = prevRes;
		list3.AddRange(await GetRestricoes(usuario, "financeiro"));
		list3 = prevRes;
		list3.AddRange(await GetRestricoes(usuario, "ferramentas"));
		list3 = prevRes;
		list3.AddRange(await GetRestricoes(usuario, "ajuda"));
		list3 = prevRes;
		list3.AddRange(await GetRestricoes(usuario, "totalizacoesRelatorios"));
		list3 = prevRes;
		list3.AddRange(await GetRestricoes(usuario, "camposRelatorios"));
		List<RestricaoUsuarioCamposRelatorios> prevResCamposRelatorios = new List<RestricaoUsuarioCamposRelatorios>();
		List<RestricaoUsuarioCamposRelatorios> list4 = prevResCamposRelatorios;
		list4.AddRange(await GetRestricoesCamposRelatorios(usuario));
		List<RestricaoUsuario> list5 = new List<RestricaoUsuario>();
		List<RestricaoUsuarioCamposRelatorios> restricoesCamposRelatorios = new List<RestricaoUsuarioCamposRelatorios>();
		List<RestricaoUsuario> collection2 = ((IEnumerable<RestricaoUsuario>)RestricoesBis).Select((Func<RestricaoUsuario, RestricaoUsuario>)((RestricaoUsuario x) => new RestricaoUsuario
		{
			Id = ((prevRes.Count == 0) ? 0 : ((DomainBase)prevRes.First((RestricaoUsuario y) => y.Tipo == x.Tipo)).Id),
			Tipo = x.Tipo,
			Restricao = x.Restricao,
			Usuario = usuario
		})).ToList();
		list5.AddRange(collection2);
		collection2 = ((IEnumerable<RestricaoUsuario>)RestricoesSeguros).Select((Func<RestricaoUsuario, RestricaoUsuario>)((RestricaoUsuario x) => new RestricaoUsuario
		{
			Id = ((prevRes.Count == 0) ? 0 : ((DomainBase)prevRes.First((RestricaoUsuario y) => y.Tipo == x.Tipo)).Id),
			Tipo = x.Tipo,
			Restricao = x.Restricao,
			Usuario = usuario
		})).ToList();
		list5.AddRange(collection2);
		collection2 = ((IEnumerable<RestricaoUsuario>)RestricoesRelatorios).Select((Func<RestricaoUsuario, RestricaoUsuario>)((RestricaoUsuario x) => new RestricaoUsuario
		{
			Id = ((prevRes.Count == 0) ? 0 : ((DomainBase)prevRes.First((RestricaoUsuario y) => y.Tipo == x.Tipo)).Id),
			Tipo = x.Tipo,
			Restricao = x.Restricao,
			Usuario = usuario
		})).ToList();
		list5.AddRange(collection2);
		collection2 = ((IEnumerable<RestricaoUsuario>)RestricoesTotalizacoesRelatorios).Select((Func<RestricaoUsuario, RestricaoUsuario>)((RestricaoUsuario x) => new RestricaoUsuario
		{
			Id = ((prevRes.Count == 0) ? 0 : ((DomainBase)prevRes.First((RestricaoUsuario y) => y.Tipo == x.Tipo)).Id),
			Tipo = x.Tipo,
			Restricao = x.Restricao,
			Usuario = usuario
		})).ToList();
		list5.AddRange(collection2);
		collection2 = ((IEnumerable<RestricaoUsuario>)RestricoesFinanceiros).Select((Func<RestricaoUsuario, RestricaoUsuario>)((RestricaoUsuario x) => new RestricaoUsuario
		{
			Id = ((prevRes.Count == 0) ? 0 : ((DomainBase)prevRes.First((RestricaoUsuario y) => y.Tipo == x.Tipo)).Id),
			Tipo = x.Tipo,
			Restricao = x.Restricao,
			Usuario = usuario
		})).ToList();
		list5.AddRange(collection2);
		collection2 = ((IEnumerable<RestricaoUsuario>)RestricoesFerramentas).Select((Func<RestricaoUsuario, RestricaoUsuario>)((RestricaoUsuario x) => new RestricaoUsuario
		{
			Id = ((prevRes.Count == 0) ? 0 : ((DomainBase)prevRes.First((RestricaoUsuario y) => y.Tipo == x.Tipo)).Id),
			Tipo = x.Tipo,
			Restricao = x.Restricao,
			Usuario = usuario
		})).ToList();
		list5.AddRange(collection2);
		collection2 = ((IEnumerable<RestricaoUsuario>)RestricoesAjudas).Select((Func<RestricaoUsuario, RestricaoUsuario>)((RestricaoUsuario x) => new RestricaoUsuario
		{
			Id = ((prevRes.Count == 0) ? 0 : ((DomainBase)prevRes.First((RestricaoUsuario y) => y.Tipo == x.Tipo)).Id),
			Tipo = x.Tipo,
			Restricao = x.Restricao,
			Usuario = usuario
		})).ToList();
		list5.AddRange(collection2);
		List<RestricaoUsuarioCamposRelatorios> collection3 = ((IEnumerable<RestricaoUsuarioCamposRelatorios>)RestricoesCamposRelatorios).Select((Func<RestricaoUsuarioCamposRelatorios, RestricaoUsuarioCamposRelatorios>)((RestricaoUsuarioCamposRelatorios x) => new RestricaoUsuarioCamposRelatorios
		{
			Id = ((prevResCamposRelatorios.Count == 0) ? 0 : ((DomainBase)prevResCamposRelatorios.First((RestricaoUsuarioCamposRelatorios y) => y.Campo == x.Campo && y.Relatorio == x.Relatorio)).Id),
			Campo = x.Campo,
			Restricao = x.Restricao,
			Relatorio = x.Relatorio,
			Usuario = usuario
		})).ToList();
		restricoesCamposRelatorios.AddRange(collection3);
		await ServicoRestriUsuario.SaveRestri(list5, prevRes);
		if (!ServicoRestriUsuario.Sucesso)
		{
			return false;
		}
		await ServicoRestriUsuario.SaveRestriCamposRelatorios(restricoesCamposRelatorios, prevResCamposRelatorios);
		if (!ServicoRestriUsuario.Sucesso)
		{
			return false;
		}
		if (registrar)
		{
			RegistrarAcao("ALTEROU PERMISSÕES/RESTRIÇÕES DO USUÁRIO \"" + SelectedUsuario.Nome + "\"", ((DomainBase)SelectedUsuario).Id, (TipoTela)43, "ACESSE O LOG DE ALTERAÇÕES NA TELA DE PERMISSÕES/RESTRIÇÕES PARA VER EXATAMENTE O QUE FOI ALTERADO.");
		}
		return true;
	}

	internal async Task<List<RestricaoUsuario>> FiltrarRestricoesBi(string value)
	{
		return await Task.Run(() => FiltrarRestricoesBis(value));
	}

	internal async Task<List<RestricaoUsuario>> FiltrarRestricoesSeguro(string value)
	{
		return await Task.Run(() => FiltrarRestricoesSeguros(value));
	}

	internal async Task<List<RestricaoUsuario>> FiltrarRestricoesRelatorio(string value)
	{
		return await Task.Run(() => FiltrarRestricoesRelatorios(value));
	}

	internal async Task<List<RestricaoUsuario>> FiltrarRestricoesTotalizacoesRelatorio(string value)
	{
		return await Task.Run(() => FiltrarRestricoesTotalizacoesRelatorios(value));
	}

	internal async Task<List<RestricaoUsuarioCamposRelatorios>> FiltrarRestricoesCamposRelatorio(string value)
	{
		return await Task.Run(() => FiltrarRestricoesCamposRelatorios(value));
	}

	internal async Task<List<RestricaoUsuario>> FiltrarRestricoesFinanceiro(string value)
	{
		return await Task.Run(() => FiltrarRestricoesFinanceiros(value));
	}

	internal async Task<List<RestricaoUsuario>> FiltrarRestricoesFerramenta(string value)
	{
		return await Task.Run(() => FiltrarRestricoesFerramentas(value));
	}

	internal async Task<List<RestricaoUsuario>> FiltrarRestricoesAjuda(string value)
	{
		return await Task.Run(() => FiltrarRestricoesAjudas(value));
	}

	public List<RestricaoUsuario> FiltrarRestricoesBis(string filter)
	{
		RestricoesBisFiltradas = ((filter == "") ? new ObservableCollection<RestricaoUsuario>(RestricoesBis) : new ObservableCollection<RestricaoUsuario>(RestricoesBis.Where((RestricaoUsuario x) => ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription((Enum)(object)x.Tipo).Trim()).ToUpper().Contains(filter.ToUpper()))));
		ExpandedBis = RestricoesBisFiltradas.Count > 0 && filter != "";
		if (!(filter == ""))
		{
			return RestricoesBisFiltradas.ToList();
		}
		return null;
	}

	public List<RestricaoUsuario> FiltrarRestricoesSeguros(string filter)
	{
		RestricoesSegurosFiltradas = ((filter == "") ? new ObservableCollection<RestricaoUsuario>(RestricoesSeguros) : new ObservableCollection<RestricaoUsuario>(RestricoesSeguros.Where((RestricaoUsuario x) => ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription((Enum)(object)x.Tipo).Trim()).ToUpper().Contains(filter.ToUpper()))));
		ExpandedSeguros = RestricoesSegurosFiltradas.Count > 0 && filter != "";
		if (!(filter == ""))
		{
			return RestricoesSegurosFiltradas.ToList();
		}
		return null;
	}

	public List<RestricaoUsuario> FiltrarRestricoesRelatorios(string filter)
	{
		RestricoesRelatoriosFiltrados = ((filter == "") ? new ObservableCollection<RestricaoUsuario>(RestricoesRelatorios) : new ObservableCollection<RestricaoUsuario>(RestricoesRelatorios.Where((RestricaoUsuario x) => ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription((Enum)(object)x.Tipo).Trim()).ToUpper().Contains(filter.ToUpper()))));
		ExpandedRelatorios = RestricoesRelatoriosFiltrados.Count > 0 && filter != "";
		if (!(filter == ""))
		{
			return RestricoesRelatoriosFiltrados.ToList();
		}
		return null;
	}

	public List<RestricaoUsuario> FiltrarRestricoesTotalizacoesRelatorios(string filter)
	{
		RestricoesTotalizacoesRelatoriosFiltrados = ((filter == "") ? new ObservableCollection<RestricaoUsuario>(RestricoesTotalizacoesRelatorios) : new ObservableCollection<RestricaoUsuario>(RestricoesTotalizacoesRelatorios.Where((RestricaoUsuario x) => ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription((Enum)(object)x.Tipo).Trim()).ToUpper().Contains(filter.ToUpper()))));
		ExpandedTotalizacoes = RestricoesTotalizacoesRelatoriosFiltrados.Count > 0 && filter != "";
		if (!(filter == ""))
		{
			return RestricoesTotalizacoesRelatoriosFiltrados.ToList();
		}
		return null;
	}

	public List<RestricaoUsuarioCamposRelatorios> FiltrarRestricoesCamposRelatorios(string filter)
	{
		RestricoesCamposRelatoriosFiltrados = ((filter == "") ? new ObservableCollection<RestricaoUsuarioCamposRelatorios>(RestricoesCamposRelatorios) : new ObservableCollection<RestricaoUsuarioCamposRelatorios>(RestricoesCamposRelatorios.Where((RestricaoUsuarioCamposRelatorios x) => ValidationHelper.RemoveDiacritics(x.Campo.ToUpper().Trim()).Contains(filter.ToUpper()) || ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription((Enum)(object)x.Relatorio).Trim()).ToUpper().Contains(filter.ToUpper()))));
		ExpandedCampos = RestricoesCamposRelatoriosFiltrados.Count > 0 && filter != "";
		if (!(filter == ""))
		{
			return RestricoesCamposRelatoriosFiltrados.ToList();
		}
		return null;
	}

	public List<RestricaoUsuario> FiltrarRestricoesFinanceiros(string filter)
	{
		RestricoesFinanceirosFiltradas = ((filter == "") ? new ObservableCollection<RestricaoUsuario>(RestricoesFinanceiros) : new ObservableCollection<RestricaoUsuario>(RestricoesFinanceiros.Where((RestricaoUsuario x) => ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription((Enum)(object)x.Tipo).Trim()).ToUpper().Contains(filter.ToUpper()))));
		ExpandedFinanceiros = RestricoesFinanceirosFiltradas.Count > 0 && filter != "";
		if (!(filter == ""))
		{
			return RestricoesFinanceirosFiltradas.ToList();
		}
		return null;
	}

	public List<RestricaoUsuario> FiltrarRestricoesFerramentas(string filter)
	{
		RestricoesFerramentasFiltradas = ((filter == "") ? new ObservableCollection<RestricaoUsuario>(RestricoesFerramentas) : new ObservableCollection<RestricaoUsuario>(RestricoesFerramentas.Where((RestricaoUsuario x) => ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription((Enum)(object)x.Tipo).Trim()).ToUpper().Contains(filter.ToUpper()))));
		ExpandedFerramentas = RestricoesFerramentasFiltradas.Count > 0 && filter != "";
		if (!(filter == ""))
		{
			return RestricoesFerramentasFiltradas.ToList();
		}
		return null;
	}

	public List<RestricaoUsuario> FiltrarRestricoesAjudas(string filter)
	{
		RestricoesAjudasFiltrados = ((filter == "") ? new ObservableCollection<RestricaoUsuario>(RestricoesAjudas) : new ObservableCollection<RestricaoUsuario>(RestricoesAjudas.Where((RestricaoUsuario x) => ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription((Enum)(object)x.Tipo).Trim()).ToUpper().Contains(filter.ToUpper()))));
		ExpandedAjudas = RestricoesAjudasFiltrados.Count > 0 && filter != "";
		if (!(filter == ""))
		{
			return RestricoesAjudasFiltrados.ToList();
		}
		return null;
	}

	public bool CopiarPermissoes(Tuple<List<PermissaoUsuario>, Usuario, List<RestricaoUsuario>, List<PermissaoArquivoDigital>, List<RestricaoUsuarioCamposRelatorios>> copiarPermiss)
	{
		if (copiarPermiss.Item1.Count > 0)
		{
			copiarPermiss.Item1.ForEach(delegate(PermissaoUsuario x)
			{
				Seguros.ToList().ForEach(delegate(PermissaoUsuario y)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					if (x.Tela == y.Tela)
					{
						y.Consultar = x.Consultar;
						y.Incluir = x.Incluir;
						y.Alterar = x.Alterar;
						y.Excluir = x.Excluir;
						y.Usuario = _selectedUsuario;
					}
				});
				Ferramentas.ToList().ForEach(delegate(PermissaoUsuario y)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					if (x.Tela == y.Tela)
					{
						y.Consultar = x.Consultar;
						y.Incluir = x.Incluir;
						y.Alterar = x.Alterar;
						y.Excluir = x.Excluir;
						y.Usuario = _selectedUsuario;
					}
				});
			});
		}
		else
		{
			Seguros.ToList().ForEach(delegate(PermissaoUsuario x)
			{
				x.Consultar = false;
				x.Incluir = false;
				x.Alterar = false;
				x.Excluir = false;
				x.Usuario = _selectedUsuario;
			});
			Ferramentas.ToList().ForEach(delegate(PermissaoUsuario x)
			{
				x.Consultar = false;
				x.Incluir = false;
				x.Alterar = false;
				x.Excluir = false;
				x.Usuario = _selectedUsuario;
			});
		}
		if (copiarPermiss.Item4.Count > 0)
		{
			copiarPermiss.Item4.ForEach(delegate(PermissaoArquivoDigital x)
			{
				ArquivosDigitais.ToList().ForEach(delegate(PermissaoArquivoDigital y)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					if (x.Tela == y.Tela)
					{
						y.Consultar = x.Consultar;
						y.Incluir = x.Incluir;
						y.Excluir = x.Excluir;
						y.Usuario = _selectedUsuario;
					}
				});
			});
		}
		else
		{
			ArquivosDigitais.ToList().ForEach(delegate(PermissaoArquivoDigital x)
			{
				x.Consultar = false;
				x.Incluir = false;
				x.Excluir = false;
				x.Usuario = _selectedUsuario;
			});
		}
		SelectedPermissao = (copiarPermiss.Item2.PermissaoAggilizador.HasValue ? ((IEnumerable<PermissaoAggilizador>)PermissaoAggilizador).FirstOrDefault((Func<PermissaoAggilizador, bool>)((PermissaoAggilizador x) => ((DomainBase)x).Id == copiarPermiss.Item2.PermissaoAggilizador)) : null);
		copiarPermiss.Item3.ForEach(delegate(RestricaoUsuario x)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			foreach (RestricaoUsuario restricoesBi in RestricoesBis)
			{
				if (restricoesBi.Tipo == x.Tipo)
				{
					restricoesBi.Restricao = x.Restricao;
					restricoesBi.Usuario = _selectedUsuario;
				}
			}
			foreach (RestricaoUsuario restricoesSeguro in RestricoesSeguros)
			{
				if (restricoesSeguro.Tipo == x.Tipo)
				{
					restricoesSeguro.Restricao = x.Restricao;
					restricoesSeguro.Usuario = _selectedUsuario;
				}
			}
			foreach (RestricaoUsuario restricoesRelatorio in RestricoesRelatorios)
			{
				if (restricoesRelatorio.Tipo == x.Tipo)
				{
					restricoesRelatorio.Restricao = x.Restricao;
					restricoesRelatorio.Usuario = _selectedUsuario;
				}
			}
			foreach (RestricaoUsuario restricoesTotalizacoesRelatorio in RestricoesTotalizacoesRelatorios)
			{
				if (restricoesTotalizacoesRelatorio.Tipo == x.Tipo)
				{
					restricoesTotalizacoesRelatorio.Restricao = x.Restricao;
					restricoesTotalizacoesRelatorio.Usuario = _selectedUsuario;
				}
			}
			foreach (RestricaoUsuario restricoesFinanceiro in RestricoesFinanceiros)
			{
				if (restricoesFinanceiro.Tipo == x.Tipo)
				{
					restricoesFinanceiro.Restricao = x.Restricao;
					restricoesFinanceiro.Usuario = _selectedUsuario;
				}
			}
			foreach (RestricaoUsuario restricoesFerramenta in RestricoesFerramentas)
			{
				if (restricoesFerramenta.Tipo == x.Tipo)
				{
					restricoesFerramenta.Restricao = x.Restricao;
					restricoesFerramenta.Usuario = _selectedUsuario;
				}
			}
			foreach (RestricaoUsuario restricoesAjuda in RestricoesAjudas)
			{
				if (restricoesAjuda.Tipo == x.Tipo)
				{
					restricoesAjuda.Restricao = x.Restricao;
					restricoesAjuda.Usuario = _selectedUsuario;
				}
			}
		});
		copiarPermiss.Item5.ForEach(delegate(RestricaoUsuarioCamposRelatorios x)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			foreach (RestricaoUsuarioCamposRelatorios restricoesCamposRelatorio in RestricoesCamposRelatorios)
			{
				if (restricoesCamposRelatorio.Campo == x.Campo && restricoesCamposRelatorio.Relatorio == x.Relatorio)
				{
					restricoesCamposRelatorio.Restricao = x.Restricao;
					restricoesCamposRelatorio.Usuario = _selectedUsuario;
				}
			}
		});
		RegistrarAcao("IMPORTOU PERMISSÕES/RESTRIÇÕES DO USUÁRIO \"" + copiarPermiss.Item2.Nome + "\"", ((DomainBase)SelectedUsuario).Id, (TipoTela)43, $"ID USUÁRIO: {((DomainBase)copiarPermiss.Item2).Id}");
		return true;
	}

	public async Task<bool> ExportarPermissoes(List<Usuario> usuarios)
	{
		foreach (Usuario item in usuarios.Where((Usuario x) => x.Selecionado))
		{
			await Salvar(((DomainBase)item).Id, registrar: false);
		}
		RegistrarAcao(string.Format("EXPORTOU PERMISSÕES/RESTRIÇÕES DO USUÁRIO \"{0}\" PARA {1} USUÁRIO{2}", SelectedUsuario.Nome, usuarios.Count, (usuarios.Count == 1) ? "" : "S"), ((DomainBase)SelectedUsuario).Id, (TipoTela)43, "IDS E NOMES DOS USUÁRIOS: " + string.Join("\n", usuarios.Select((Usuario x) => $"{((DomainBase)x).Id}: \"{x.Nome}\"")));
		return true;
	}

	public void AtivarDesativarPermissoes(bool permiss)
	{
		AtivarDesativarPermissoesBool = !permiss;
		Seguros.ToList().ForEach(delegate(PermissaoUsuario x)
		{
			x.Consultar = permiss;
			x.Incluir = permiss;
			x.Alterar = permiss;
			x.Excluir = permiss;
		});
		Ferramentas.ToList().ForEach(delegate(PermissaoUsuario x)
		{
			x.Consultar = permiss;
			x.Incluir = permiss;
			x.Alterar = permiss;
			x.Excluir = permiss;
		});
		ArquivosDigitais.ToList().ForEach(delegate(PermissaoArquivoDigital x)
		{
			x.Consultar = permiss;
			x.Incluir = permiss;
			x.Excluir = permiss;
		});
		SelectedPermissao = (permiss ? ((IEnumerable<PermissaoAggilizador>)PermissaoAggilizador).FirstOrDefault((Func<PermissaoAggilizador, bool>)((PermissaoAggilizador x) => x.Descricao == "ADMINISTRADOR")) : null);
		Seguros = new ObservableCollection<PermissaoUsuario>(Seguros);
		Ferramentas = new ObservableCollection<PermissaoUsuario>(Ferramentas);
		ArquivosDigitais = new ObservableCollection<PermissaoArquivoDigital>(ArquivosDigitais);
	}

	public void AtivarDesativarRestricoes(bool restricao)
	{
		AtivarDesativarRestricoesBool = !restricao;
		foreach (RestricaoUsuario restricoesBisFiltrada in RestricoesBisFiltradas)
		{
			restricoesBisFiltrada.Restricao = restricao;
		}
		foreach (RestricaoUsuario restricoesSegurosFiltrada in RestricoesSegurosFiltradas)
		{
			restricoesSegurosFiltrada.Restricao = restricao;
		}
		foreach (RestricaoUsuario restricoesRelatoriosFiltrado in RestricoesRelatoriosFiltrados)
		{
			restricoesRelatoriosFiltrado.Restricao = restricao;
		}
		foreach (RestricaoUsuario restricoesTotalizacoesRelatoriosFiltrado in RestricoesTotalizacoesRelatoriosFiltrados)
		{
			restricoesTotalizacoesRelatoriosFiltrado.Restricao = restricao;
		}
		foreach (RestricaoUsuarioCamposRelatorios restricoesCamposRelatoriosFiltrado in RestricoesCamposRelatoriosFiltrados)
		{
			restricoesCamposRelatoriosFiltrado.Restricao = restricao;
		}
		foreach (RestricaoUsuario restricoesFinanceirosFiltrada in RestricoesFinanceirosFiltradas)
		{
			restricoesFinanceirosFiltrada.Restricao = restricao;
		}
		foreach (RestricaoUsuario restricoesFerramentasFiltrada in RestricoesFerramentasFiltradas)
		{
			restricoesFerramentasFiltrada.Restricao = restricao;
		}
		foreach (RestricaoUsuario restricoesAjudasFiltrado in RestricoesAjudasFiltrados)
		{
			restricoesAjudasFiltrado.Restricao = restricao;
		}
		RestricoesBisFiltradas = new ObservableCollection<RestricaoUsuario>(RestricoesBisFiltradas);
		RestricoesSegurosFiltradas = new ObservableCollection<RestricaoUsuario>(RestricoesSegurosFiltradas);
		RestricoesRelatoriosFiltrados = new ObservableCollection<RestricaoUsuario>(RestricoesRelatoriosFiltrados);
		RestricoesTotalizacoesRelatoriosFiltrados = new ObservableCollection<RestricaoUsuario>(RestricoesTotalizacoesRelatoriosFiltrados);
		RestricoesCamposRelatoriosFiltrados = new ObservableCollection<RestricaoUsuarioCamposRelatorios>(RestricoesCamposRelatoriosFiltrados);
		RestricoesFinanceirosFiltradas = new ObservableCollection<RestricaoUsuario>(RestricoesFinanceirosFiltradas);
		RestricoesFerramentasFiltradas = new ObservableCollection<RestricaoUsuario>(RestricoesFerramentasFiltradas);
		RestricoesAjudasFiltrados = new ObservableCollection<RestricaoUsuario>(RestricoesAjudasFiltrados);
	}

	public void AtivarDesativarRestricoes()
	{
		if (RestricoesBisFiltradas != null && RestricoesAjudasFiltrados != null && RestricoesSegurosFiltradas != null && RestricoesRelatoriosFiltrados != null && RestricoesFinanceirosFiltradas != null && RestricoesFerramentasFiltradas != null && RestricoesTotalizacoesRelatoriosFiltrados != null && RestricoesCamposRelatoriosFiltrados != null && RestricoesBisFiltradas.All((RestricaoUsuario x) => x.Restricao) && RestricoesAjudasFiltrados.All((RestricaoUsuario x) => x.Restricao) && RestricoesSegurosFiltradas.All((RestricaoUsuario x) => x.Restricao) && RestricoesRelatoriosFiltrados.All((RestricaoUsuario x) => x.Restricao) && RestricoesFinanceirosFiltradas.All((RestricaoUsuario x) => x.Restricao) && RestricoesFerramentasFiltradas.All((RestricaoUsuario x) => x.Restricao) && RestricoesTotalizacoesRelatoriosFiltrados.All((RestricaoUsuario x) => x.Restricao) && RestricoesCamposRelatoriosFiltrados.All((RestricaoUsuarioCamposRelatorios x) => x.Restricao))
		{
			AtivarDesativarRestricoesBool = false;
		}
	}

	public void DesabilitarArquivoDigital(PermissaoArquivoDigital desabilitar)
	{
		PermissaoArquivoDigital val = ArquivosDigitais.First((PermissaoArquivoDigital x) => x.Tela == desabilitar.Tela);
		if (val.Incluir || val.Excluir)
		{
			val.Incluir = false;
			val.Excluir = false;
			ArquivosDigitais = new ObservableCollection<PermissaoArquivoDigital>(ArquivosDigitais);
		}
	}

	public void DesabilitarConsulta(PermissaoUsuario desabilitar, string source)
	{
		if (!(source == "Ferramentas"))
		{
			PermissaoUsuario val = Seguros.First((PermissaoUsuario x) => x.Tela == desabilitar.Tela);
			if (val.Incluir || val.Alterar || val.Excluir)
			{
				val.Alterar = false;
				val.Incluir = false;
				val.Excluir = false;
				Seguros = new ObservableCollection<PermissaoUsuario>(Seguros);
			}
		}
		else
		{
			PermissaoUsuario val2 = Ferramentas.First((PermissaoUsuario x) => x.Tela == desabilitar.Tela);
			if (val2.Incluir || val2.Alterar || val2.Excluir)
			{
				val2.Alterar = false;
				val2.Incluir = false;
				val2.Excluir = false;
				Ferramentas = new ObservableCollection<PermissaoUsuario>(Ferramentas);
			}
		}
	}

	public void HabilitarArquivoDigital(PermissaoArquivoDigital habilitar)
	{
		PermissaoArquivoDigital val = ArquivosDigitais.First((PermissaoArquivoDigital x) => x.Tela == habilitar.Tela);
		if (!val.Consultar)
		{
			val.Consultar = true;
			ArquivosDigitais = new ObservableCollection<PermissaoArquivoDigital>(ArquivosDigitais);
		}
	}

	public void HabilitarConsulta(PermissaoUsuario habilitar, string source)
	{
		if (!(source == "Ferramentas"))
		{
			PermissaoUsuario val = Seguros.First((PermissaoUsuario x) => x.Tela == habilitar.Tela);
			if (!val.Consultar)
			{
				val.Consultar = true;
				Seguros = new ObservableCollection<PermissaoUsuario>(Seguros);
			}
		}
		else
		{
			PermissaoUsuario val2 = Ferramentas.First((PermissaoUsuario x) => x.Tela == habilitar.Tela);
			if (!val2.Consultar)
			{
				val2.Consultar = true;
				Ferramentas = new ObservableCollection<PermissaoUsuario>(Ferramentas);
			}
		}
	}
}