using Gestor.Application.Actions;
using Gestor.Application.Helpers;
using Gestor.Application.Servicos;
using Gestor.Application.Servicos.Ferramentas;
using Gestor.Application.Servicos.Generic;
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.Seguros;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using System.Windows;

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<Gestor.Model.Common.PermissaoAggilizador> _permissaoAggilizador;

		private Gestor.Model.Common.PermissaoAggilizador _selectedPermissao;

		private bool _admUsuario;

		private bool _importarEnabled;

		private bool _carregando;

		private bool _ativarDesativarPermissoesBool = true;

		private bool _ativarDesativarRestricoesBool = true;

		public bool AdmUsuario
		{
			get
			{
				return this._admUsuario;
			}
			set
			{
				this._admUsuario = value;
				this.ImportarEnabled = !value;
				this.SelectedUsuario.set_Administrador(value);
				if (value && !this.Carregando)
				{
					this.AtivarDesativarPermissoes(true);
					this.AtivarDesativarRestricoes(false);
				}
				base.OnPropertyChanged("AdmUsuario");
			}
		}

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

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

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

		public bool Carregado
		{
			get;
			set;
		}

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

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

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

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

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

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

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

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

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

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

		public ObservableCollection<PermissaoUsuario> Ferramentas
		{
			get
			{
				return this._ferramentas;
			}
			set
			{
				this._ferramentas = value;
				base.OnPropertyChanged("Ferramentas");
				if (value != null && this.Seguros != null)
				{
					if (value.All<PermissaoUsuario>((PermissaoUsuario x) => {
						if (x.get_Tela() == 18 && x.get_Consultar() && x.get_Alterar() || x.get_Tela() == 10 && x.get_Consultar() && x.get_Alterar() && x.get_Incluir() || x.get_Tela() == 12 && x.get_Consultar() && x.get_Alterar() || x.get_Tela() == 13 && x.get_Consultar() && x.get_Alterar() && x.get_Incluir())
						{
							return true;
						}
						if (x.get_Tela() == 18 || x.get_Tela() == 10 || x.get_Tela() == 12 || x.get_Tela() == 13 || !x.get_Consultar() || !x.get_Alterar() || !x.get_Incluir())
						{
							return false;
						}
						return x.get_Excluir();
					}))
					{
						if (this.Seguros.All<PermissaoUsuario>((PermissaoUsuario x) => {
							if (x.get_Tela() == 21 && x.get_Consultar() || x.get_Tela() == 5 && x.get_Alterar() && x.get_Incluir() && x.get_Excluir())
							{
								return true;
							}
							if (x.get_Tela() == 21 || x.get_Tela() == 5 || !x.get_Consultar() || !x.get_Alterar() || !x.get_Incluir())
							{
								return false;
							}
							return x.get_Excluir();
						}))
						{
							this.AtivarDesativarPermissoesBool = false;
						}
					}
				}
				Gestor.Application.Actions.Actions.OcultarTogglesFerramentas();
			}
		}

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

		public List<Gestor.Model.Common.PermissaoAggilizador> PermissaoAggilizador
		{
			get
			{
				return this._permissaoAggilizador;
			}
			set
			{
				this._permissaoAggilizador = value;
				base.OnPropertyChanged("PermissaoAggilizador");
			}
		}

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

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

		public Visibility RestricoesAjudasVisibility
		{
			get
			{
				return this._restricoesAjudasVisibility;
			}
			set
			{
				this._restricoesAjudasVisibility = value;
				base.OnPropertyChanged("RestricoesAjudasVisibility");
			}
		}

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

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

		public Visibility RestricoesBisVisibility
		{
			get
			{
				return this._restricoesBisVisibility;
			}
			set
			{
				this._restricoesBisVisibility = value;
				base.OnPropertyChanged("RestricoesBisVisibility");
			}
		}

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

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

		public Visibility RestricoesCamposRelatoriosVisibility
		{
			get
			{
				return this._restricoesCamposRelatoriosVisibility;
			}
			set
			{
				this._restricoesCamposRelatoriosVisibility = value;
				base.OnPropertyChanged("RestricoesCamposRelatoriosVisibility");
			}
		}

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

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

		public Visibility RestricoesFerramentasVisibility
		{
			get
			{
				return this._restricoesFerramentasVisibility;
			}
			set
			{
				this._restricoesFerramentasVisibility = value;
				base.OnPropertyChanged("RestricoesFerramentasVisibility");
			}
		}

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

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

		public Visibility RestricoesFinanceirosVisibility
		{
			get
			{
				return this._restricoesFinanceirosVisibility;
			}
			set
			{
				this._restricoesFinanceirosVisibility = value;
				base.OnPropertyChanged("RestricoesFinanceirosVisibility");
			}
		}

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

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

		public Visibility RestricoesRelatoriosVisibility
		{
			get
			{
				return this._restricoesRelatoriosVisibility;
			}
			set
			{
				this._restricoesRelatoriosVisibility = value;
				base.OnPropertyChanged("RestricoesRelatoriosVisibility");
			}
		}

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

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

		public Visibility RestricoesSegurosVisibility
		{
			get
			{
				return this._restricoesSegurosVisibility;
			}
			set
			{
				this._restricoesSegurosVisibility = value;
				base.OnPropertyChanged("RestricoesSegurosVisibility");
			}
		}

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

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

		public Visibility RestricoesTotalizacoesRelatoriosVisibility
		{
			get
			{
				return this._restricoesTotalizacoesRelatoriosVisibility;
			}
			set
			{
				this._restricoesTotalizacoesRelatoriosVisibility = value;
				base.OnPropertyChanged("RestricoesTotalizacoesRelatoriosVisibility");
			}
		}

		public ObservableCollection<PermissaoUsuario> Seguros
		{
			get
			{
				return this._seguros;
			}
			set
			{
				this._seguros = value;
				base.OnPropertyChanged("Seguros");
				if (value != null && this.Ferramentas != null)
				{
					if (value.All<PermissaoUsuario>((PermissaoUsuario x) => {
						if (x.get_Tela() == 21 && x.get_Consultar() || x.get_Tela() == 5 && x.get_Alterar() && x.get_Incluir() && x.get_Excluir())
						{
							return true;
						}
						if (x.get_Tela() == 21 || x.get_Tela() == 5 || !x.get_Consultar() || !x.get_Alterar() || !x.get_Incluir())
						{
							return false;
						}
						return x.get_Excluir();
					}))
					{
						if (this.Ferramentas.All<PermissaoUsuario>((PermissaoUsuario x) => {
							if (x.get_Tela() == 18 && x.get_Consultar() && x.get_Alterar() || x.get_Tela() == 10 && x.get_Consultar() && x.get_Alterar() && x.get_Incluir() || x.get_Tela() == 12 && x.get_Consultar() && x.get_Alterar() || x.get_Tela() == 13 && x.get_Consultar() && x.get_Alterar() && x.get_Incluir())
							{
								return true;
							}
							if (x.get_Tela() == 18 || x.get_Tela() == 10 || x.get_Tela() == 12 || x.get_Tela() == 13 || !x.get_Consultar() || !x.get_Alterar() || !x.get_Incluir())
							{
								return false;
							}
							return x.get_Excluir();
						}))
						{
							this.AtivarDesativarPermissoesBool = false;
						}
					}
				}
				Gestor.Application.Actions.Actions.OcultarTogglesSeguros();
			}
		}

		public Gestor.Model.Common.PermissaoAggilizador SelectedPermissao
		{
			get
			{
				return this._selectedPermissao;
			}
			set
			{
				this._selectedPermissao = value;
				base.OnPropertyChanged("SelectedPermissao");
			}
		}

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

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

		public void AtivarDesativarPermissoes(bool permiss)
		{
			Gestor.Model.Common.PermissaoAggilizador permissaoAggilizador;
			this.AtivarDesativarPermissoesBool = !permiss;
			this.Seguros.ToList<PermissaoUsuario>().ForEach((PermissaoUsuario x) => {
				x.set_Consultar(permiss);
				x.set_Incluir(permiss);
				x.set_Alterar(permiss);
				x.set_Excluir(permiss);
			});
			this.Ferramentas.ToList<PermissaoUsuario>().ForEach((PermissaoUsuario x) => {
				x.set_Consultar(permiss);
				x.set_Incluir(permiss);
				x.set_Alterar(permiss);
				x.set_Excluir(permiss);
			});
			this.ArquivosDigitais.ToList<PermissaoArquivoDigital>().ForEach((PermissaoArquivoDigital x) => {
				x.set_Consultar(permiss);
				x.set_Incluir(permiss);
				x.set_Excluir(permiss);
			});
			if (permiss)
			{
				permissaoAggilizador = this.PermissaoAggilizador.FirstOrDefault<Gestor.Model.Common.PermissaoAggilizador>((Gestor.Model.Common.PermissaoAggilizador x) => x.get_Descricao() == "ADMINISTRADOR");
			}
			else
			{
				permissaoAggilizador = null;
			}
			this.SelectedPermissao = permissaoAggilizador;
			this.Seguros = new ObservableCollection<PermissaoUsuario>(this.Seguros);
			this.Ferramentas = new ObservableCollection<PermissaoUsuario>(this.Ferramentas);
			this.ArquivosDigitais = new ObservableCollection<PermissaoArquivoDigital>(this.ArquivosDigitais);
		}

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

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

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

		public bool CopiarPermissoes(Tuple<List<PermissaoUsuario>, Usuario, List<RestricaoUsuario>, List<PermissaoArquivoDigital>, List<RestricaoUsuarioCamposRelatorios>> copiarPermiss)
		{
			Gestor.Model.Common.PermissaoAggilizador permissaoAggilizador1;
			if (copiarPermiss.Item1.Count <= 0)
			{
				this.Seguros.ToList<PermissaoUsuario>().ForEach((PermissaoUsuario x) => {
					x.set_Consultar(false);
					x.set_Incluir(false);
					x.set_Alterar(false);
					x.set_Excluir(false);
					x.set_Usuario(this._selectedUsuario);
				});
				this.Ferramentas.ToList<PermissaoUsuario>().ForEach((PermissaoUsuario x) => {
					x.set_Consultar(false);
					x.set_Incluir(false);
					x.set_Alterar(false);
					x.set_Excluir(false);
					x.set_Usuario(this._selectedUsuario);
				});
			}
			else
			{
				copiarPermiss.Item1.ForEach((PermissaoUsuario x) => {
					this.Seguros.ToList<PermissaoUsuario>().ForEach((PermissaoUsuario y) => {
						if (x.get_Tela() != y.get_Tela())
						{
							return;
						}
						y.set_Consultar(x.get_Consultar());
						y.set_Incluir(x.get_Incluir());
						y.set_Alterar(x.get_Alterar());
						y.set_Excluir(x.get_Excluir());
						y.set_Usuario(this._selectedUsuario);
					});
					this.Ferramentas.ToList<PermissaoUsuario>().ForEach((PermissaoUsuario y) => {
						if (x.get_Tela() != y.get_Tela())
						{
							return;
						}
						y.set_Consultar(x.get_Consultar());
						y.set_Incluir(x.get_Incluir());
						y.set_Alterar(x.get_Alterar());
						y.set_Excluir(x.get_Excluir());
						y.set_Usuario(this._selectedUsuario);
					});
				});
			}
			if (copiarPermiss.Item4.Count <= 0)
			{
				this.ArquivosDigitais.ToList<PermissaoArquivoDigital>().ForEach((PermissaoArquivoDigital x) => {
					x.set_Consultar(false);
					x.set_Incluir(false);
					x.set_Excluir(false);
					x.set_Usuario(this._selectedUsuario);
				});
			}
			else
			{
				copiarPermiss.Item4.ForEach((PermissaoArquivoDigital x) => this.ArquivosDigitais.ToList<PermissaoArquivoDigital>().ForEach((PermissaoArquivoDigital y) => {
					if (x.get_Tela() != y.get_Tela())
					{
						return;
					}
					y.set_Consultar(x.get_Consultar());
					y.set_Incluir(x.get_Incluir());
					y.set_Excluir(x.get_Excluir());
					y.set_Usuario(this._selectedUsuario);
				}));
			}
			if (copiarPermiss.Item2.get_PermissaoAggilizador().HasValue)
			{
				permissaoAggilizador1 = this.PermissaoAggilizador.FirstOrDefault<Gestor.Model.Common.PermissaoAggilizador>((Gestor.Model.Common.PermissaoAggilizador x) => {
					long id = x.get_Id();
					long? permissaoAggilizador = copiarPermiss.Item2.get_PermissaoAggilizador();
					return id == permissaoAggilizador.GetValueOrDefault() & permissaoAggilizador.HasValue;
				});
			}
			else
			{
				permissaoAggilizador1 = null;
			}
			this.SelectedPermissao = permissaoAggilizador1;
			copiarPermiss.Item3.ForEach((RestricaoUsuario x) => {
				foreach (RestricaoUsuario restricoesBi in this.RestricoesBis)
				{
					if (restricoesBi.get_Tipo() != x.get_Tipo())
					{
						continue;
					}
					restricoesBi.set_Restricao(x.get_Restricao());
					restricoesBi.set_Usuario(this._selectedUsuario);
				}
				foreach (RestricaoUsuario restricoesSeguro in this.RestricoesSeguros)
				{
					if (restricoesSeguro.get_Tipo() != x.get_Tipo())
					{
						continue;
					}
					restricoesSeguro.set_Restricao(x.get_Restricao());
					restricoesSeguro.set_Usuario(this._selectedUsuario);
				}
				foreach (RestricaoUsuario restricoesRelatorio in this.RestricoesRelatorios)
				{
					if (restricoesRelatorio.get_Tipo() != x.get_Tipo())
					{
						continue;
					}
					restricoesRelatorio.set_Restricao(x.get_Restricao());
					restricoesRelatorio.set_Usuario(this._selectedUsuario);
				}
				foreach (RestricaoUsuario restricoesTotalizacoesRelatorio in this.RestricoesTotalizacoesRelatorios)
				{
					if (restricoesTotalizacoesRelatorio.get_Tipo() != x.get_Tipo())
					{
						continue;
					}
					restricoesTotalizacoesRelatorio.set_Restricao(x.get_Restricao());
					restricoesTotalizacoesRelatorio.set_Usuario(this._selectedUsuario);
				}
				foreach (RestricaoUsuario restricoesFinanceiro in this.RestricoesFinanceiros)
				{
					if (restricoesFinanceiro.get_Tipo() != x.get_Tipo())
					{
						continue;
					}
					restricoesFinanceiro.set_Restricao(x.get_Restricao());
					restricoesFinanceiro.set_Usuario(this._selectedUsuario);
				}
				foreach (RestricaoUsuario restricoesFerramenta in this.RestricoesFerramentas)
				{
					if (restricoesFerramenta.get_Tipo() != x.get_Tipo())
					{
						continue;
					}
					restricoesFerramenta.set_Restricao(x.get_Restricao());
					restricoesFerramenta.set_Usuario(this._selectedUsuario);
				}
				foreach (RestricaoUsuario restricoesAjuda in this.RestricoesAjudas)
				{
					if (restricoesAjuda.get_Tipo() != x.get_Tipo())
					{
						continue;
					}
					restricoesAjuda.set_Restricao(x.get_Restricao());
					restricoesAjuda.set_Usuario(this._selectedUsuario);
				}
			});
			copiarPermiss.Item5.ForEach((RestricaoUsuarioCamposRelatorios x) => {
				foreach (RestricaoUsuarioCamposRelatorios restricoesCamposRelatorio in this.RestricoesCamposRelatorios)
				{
					if (!(restricoesCamposRelatorio.get_Campo() == x.get_Campo()) || restricoesCamposRelatorio.get_Relatorio() != x.get_Relatorio())
					{
						continue;
					}
					restricoesCamposRelatorio.set_Restricao(x.get_Restricao());
					restricoesCamposRelatorio.set_Usuario(this._selectedUsuario);
				}
			});
			base.RegistrarAcao(string.Concat("IMPORTOU PERMISSÕES/RESTRIÇÕES DO USUÁRIO \"", copiarPermiss.Item2.get_Nome(), "\""), this.SelectedUsuario.get_Id(), new TipoTela?(43), string.Format("ID USUÁRIO: {0}", copiarPermiss.Item2.get_Id()));
			return true;
		}

		public void DesabilitarArquivoDigital(PermissaoArquivoDigital desabilitar)
		{
			PermissaoArquivoDigital permissaoArquivoDigital = this.ArquivosDigitais.First<PermissaoArquivoDigital>((PermissaoArquivoDigital x) => x.get_Tela() == desabilitar.get_Tela());
			if (!permissaoArquivoDigital.get_Incluir() && !permissaoArquivoDigital.get_Excluir())
			{
				return;
			}
			permissaoArquivoDigital.set_Incluir(false);
			permissaoArquivoDigital.set_Excluir(false);
			this.ArquivosDigitais = new ObservableCollection<PermissaoArquivoDigital>(this.ArquivosDigitais);
		}

		public void DesabilitarConsulta(PermissaoUsuario desabilitar, string source)
		{
			if (source != "Ferramentas")
			{
				PermissaoUsuario permissaoUsuario = this.Seguros.First<PermissaoUsuario>((PermissaoUsuario x) => x.get_Tela() == desabilitar.get_Tela());
				if (!permissaoUsuario.get_Incluir() && !permissaoUsuario.get_Alterar() && !permissaoUsuario.get_Excluir())
				{
					return;
				}
				permissaoUsuario.set_Alterar(false);
				permissaoUsuario.set_Incluir(false);
				permissaoUsuario.set_Excluir(false);
				this.Seguros = new ObservableCollection<PermissaoUsuario>(this.Seguros);
				return;
			}
			PermissaoUsuario permissaoUsuario1 = this.Ferramentas.First<PermissaoUsuario>((PermissaoUsuario x) => x.get_Tela() == desabilitar.get_Tela());
			if (!permissaoUsuario1.get_Incluir() && !permissaoUsuario1.get_Alterar() && !permissaoUsuario1.get_Excluir())
			{
				return;
			}
			permissaoUsuario1.set_Alterar(false);
			permissaoUsuario1.set_Incluir(false);
			permissaoUsuario1.set_Excluir(false);
			this.Ferramentas = new ObservableCollection<PermissaoUsuario>(this.Ferramentas);
		}

		public async Task<bool> ExportarPermissoes(List<Usuario> usuarios)
		{
			object obj;
			List<Usuario> usuarios1 = usuarios;
			foreach (Usuario usuario in 
				from x in usuarios1
				where x.get_Selecionado()
				select x)
			{
				await this.Salvar(new long?(usuario.get_Id()), false);
			}
			PermissaoUsuarioViewModel permissaoUsuarioViewModel = this;
			string nome = this.SelectedUsuario.get_Nome();
			object count = usuarios.Count;
			obj = (usuarios.Count == 1 ? "" : "S");
			string str = string.Format("EXPORTOU PERMISSÕES/RESTRIÇÕES DO USUÁRIO \"{0}\" PARA {1} USUÁRIO{2}", nome, count, obj);
			long id = this.SelectedUsuario.get_Id();
			TipoTela? nullable = new TipoTela?(43);
			List<Usuario> usuarios2 = usuarios;
			permissaoUsuarioViewModel.RegistrarAcao(str, id, nullable, string.Concat("IDS E NOMES DOS USUÁRIOS: ", string.Join("\n", 
				from x in usuarios2
				select string.Format("{0}: \"{1}\"", x.get_Id(), x.get_Nome()))));
			return true;
		}

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

		public List<RestricaoUsuario> FiltrarRestricoesAjudas(string filter)
		{
			this.RestricoesAjudasFiltrados = (filter == "" ? new ObservableCollection<RestricaoUsuario>(this.RestricoesAjudas) : new ObservableCollection<RestricaoUsuario>(
				from x in this.RestricoesAjudas
				where ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription(x.get_Tipo()).Trim()).ToUpper().Contains(filter.ToUpper())
				select x));
			this.ExpandedAjudas = (this.RestricoesAjudasFiltrados.Count <= 0 ? false : filter != "");
			if (filter == "")
			{
				return null;
			}
			return this.RestricoesAjudasFiltrados.ToList<RestricaoUsuario>();
		}

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

		public List<RestricaoUsuario> FiltrarRestricoesBis(string filter)
		{
			this.RestricoesBisFiltradas = (filter == "" ? new ObservableCollection<RestricaoUsuario>(this.RestricoesBis) : new ObservableCollection<RestricaoUsuario>(
				from x in this.RestricoesBis
				where ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription(x.get_Tipo()).Trim()).ToUpper().Contains(filter.ToUpper())
				select x));
			this.ExpandedBis = (this.RestricoesBisFiltradas.Count <= 0 ? false : filter != "");
			if (filter == "")
			{
				return null;
			}
			return this.RestricoesBisFiltradas.ToList<RestricaoUsuario>();
		}

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

		public List<RestricaoUsuarioCamposRelatorios> FiltrarRestricoesCamposRelatorios(string filter)
		{
			this.RestricoesCamposRelatoriosFiltrados = (filter == "" ? new ObservableCollection<RestricaoUsuarioCamposRelatorios>(this.RestricoesCamposRelatorios) : new ObservableCollection<RestricaoUsuarioCamposRelatorios>(this.RestricoesCamposRelatorios.Where<RestricaoUsuarioCamposRelatorios>((RestricaoUsuarioCamposRelatorios x) => {
				if (ValidationHelper.RemoveDiacritics(x.get_Campo().ToUpper().Trim()).Contains(filter.ToUpper()))
				{
					return true;
				}
				return ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription(x.get_Relatorio()).Trim()).ToUpper().Contains(filter.ToUpper());
			})));
			this.ExpandedCampos = (this.RestricoesCamposRelatoriosFiltrados.Count <= 0 ? false : filter != "");
			if (filter == "")
			{
				return null;
			}
			return this.RestricoesCamposRelatoriosFiltrados.ToList<RestricaoUsuarioCamposRelatorios>();
		}

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

		public List<RestricaoUsuario> FiltrarRestricoesFerramentas(string filter)
		{
			this.RestricoesFerramentasFiltradas = (filter == "" ? new ObservableCollection<RestricaoUsuario>(this.RestricoesFerramentas) : new ObservableCollection<RestricaoUsuario>(
				from x in this.RestricoesFerramentas
				where ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription(x.get_Tipo()).Trim()).ToUpper().Contains(filter.ToUpper())
				select x));
			this.ExpandedFerramentas = (this.RestricoesFerramentasFiltradas.Count <= 0 ? false : filter != "");
			if (filter == "")
			{
				return null;
			}
			return this.RestricoesFerramentasFiltradas.ToList<RestricaoUsuario>();
		}

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

		public List<RestricaoUsuario> FiltrarRestricoesFinanceiros(string filter)
		{
			this.RestricoesFinanceirosFiltradas = (filter == "" ? new ObservableCollection<RestricaoUsuario>(this.RestricoesFinanceiros) : new ObservableCollection<RestricaoUsuario>(
				from x in this.RestricoesFinanceiros
				where ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription(x.get_Tipo()).Trim()).ToUpper().Contains(filter.ToUpper())
				select x));
			this.ExpandedFinanceiros = (this.RestricoesFinanceirosFiltradas.Count <= 0 ? false : filter != "");
			if (filter == "")
			{
				return null;
			}
			return this.RestricoesFinanceirosFiltradas.ToList<RestricaoUsuario>();
		}

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

		public List<RestricaoUsuario> FiltrarRestricoesRelatorios(string filter)
		{
			this.RestricoesRelatoriosFiltrados = (filter == "" ? new ObservableCollection<RestricaoUsuario>(this.RestricoesRelatorios) : new ObservableCollection<RestricaoUsuario>(
				from x in this.RestricoesRelatorios
				where ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription(x.get_Tipo()).Trim()).ToUpper().Contains(filter.ToUpper())
				select x));
			this.ExpandedRelatorios = (this.RestricoesRelatoriosFiltrados.Count <= 0 ? false : filter != "");
			if (filter == "")
			{
				return null;
			}
			return this.RestricoesRelatoriosFiltrados.ToList<RestricaoUsuario>();
		}

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

		public List<RestricaoUsuario> FiltrarRestricoesSeguros(string filter)
		{
			this.RestricoesSegurosFiltradas = (filter == "" ? new ObservableCollection<RestricaoUsuario>(this.RestricoesSeguros) : new ObservableCollection<RestricaoUsuario>(
				from x in this.RestricoesSeguros
				where ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription(x.get_Tipo()).Trim()).ToUpper().Contains(filter.ToUpper())
				select x));
			this.ExpandedSeguros = (this.RestricoesSegurosFiltradas.Count <= 0 ? false : filter != "");
			if (filter == "")
			{
				return null;
			}
			return this.RestricoesSegurosFiltradas.ToList<RestricaoUsuario>();
		}

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

		public List<RestricaoUsuario> FiltrarRestricoesTotalizacoesRelatorios(string filter)
		{
			this.RestricoesTotalizacoesRelatoriosFiltrados = (filter == "" ? new ObservableCollection<RestricaoUsuario>(this.RestricoesTotalizacoesRelatorios) : new ObservableCollection<RestricaoUsuario>(
				from x in this.RestricoesTotalizacoesRelatorios
				where ValidationHelper.RemoveDiacritics(ValidationHelper.GetDescription(x.get_Tipo()).Trim()).ToUpper().Contains(filter.ToUpper())
				select x));
			this.ExpandedTotalizacoes = (this.RestricoesTotalizacoesRelatoriosFiltrados.Count <= 0 ? false : filter != "");
			if (filter == "")
			{
				return null;
			}
			return this.RestricoesTotalizacoesRelatoriosFiltrados.ToList<RestricaoUsuario>();
		}

		private async Task<List<PermissaoUsuario>> GetPermissoes(Usuario usuario, string modulo)
		{
			List<PermissaoUsuario> permissaoUsuarios = new List<PermissaoUsuario>();
			IEnumerable<TipoTela> tipoTelas = Enum.GetValues(typeof(TipoTela)).Cast<TipoTela>();
			IEnumerable<string> str = 
				from v in tipoTelas
				select v.ToString();
			List<string> list = (
				from x in str
				orderby x
				select x).ToList<string>();
			List<PermissaoUsuario> permissaoUsuarios1 = await this.ServicoPermissUsuario.PermissUsuario(usuario);
			list.ForEach((string x) => {
				TipoTela tipoTela = (TipoTela)Enum.Parse(typeof(TipoTela), x);
				if (!string.Equals(ValidationHelper.GetCategory(tipoTela), modulo, StringComparison.CurrentCultureIgnoreCase))
				{
					return;
				}
				long id = (long)0;
				bool consultar = true;
				bool incluir = true;
				bool alterar = true;
				bool excluir = true;
				if (permissaoUsuarios1.Count > 0 && permissaoUsuarios1.Any<PermissaoUsuario>((PermissaoUsuario y) => y.get_Tela() == tipoTela))
				{
					id = permissaoUsuarios1.First<PermissaoUsuario>((PermissaoUsuario y) => y.get_Tela() == tipoTela).get_Id();
					consultar = permissaoUsuarios1.First<PermissaoUsuario>((PermissaoUsuario y) => y.get_Tela() == tipoTela).get_Consultar();
					incluir = permissaoUsuarios1.First<PermissaoUsuario>((PermissaoUsuario y) => y.get_Tela() == tipoTela).get_Incluir();
					alterar = permissaoUsuarios1.First<PermissaoUsuario>((PermissaoUsuario y) => y.get_Tela() == tipoTela).get_Alterar();
					excluir = permissaoUsuarios1.First<PermissaoUsuario>((PermissaoUsuario y) => y.get_Tela() == tipoTela).get_Excluir();
				}
				PermissaoUsuario permissaoUsuario = new PermissaoUsuario();
				permissaoUsuario.set_Id(id);
				permissaoUsuario.set_Tela(tipoTela);
				permissaoUsuario.set_Consultar(consultar);
				permissaoUsuario.set_Incluir(incluir);
				permissaoUsuario.set_Alterar(alterar);
				permissaoUsuario.set_Excluir(excluir);
				permissaoUsuarios.Add(permissaoUsuario);
			});
			List<PermissaoUsuario> permissaoUsuarios2 = permissaoUsuarios;
			list = null;
			return permissaoUsuarios2;
		}

		private async Task<List<PermissaoArquivoDigital>> GetPermissoesArquivoDigital(Usuario usuario)
		{
			List<PermissaoArquivoDigital> permissaoArquivoDigitals = new List<PermissaoArquivoDigital>();
			IEnumerable<TipoArquivoDigital> tipoArquivoDigitals = Enum.GetValues(typeof(TipoArquivoDigital)).Cast<TipoArquivoDigital>();
			IEnumerable<string> str = 
				from v in tipoArquivoDigitals
				select v.ToString();
			List<string> list = (
				from x in str
				orderby x
				select x).ToList<string>();
			List<PermissaoArquivoDigital> permissaoArquivoDigitals1 = await this.ServicoPermissArquivoDigital.PermissArquivoDigital(usuario);
			list.ForEach((string x) => {
				TipoArquivoDigital tipoArquivoDigital = (TipoArquivoDigital)Enum.Parse(typeof(TipoArquivoDigital), x);
				long id = (long)0;
				bool consultar = true;
				bool incluir = true;
				bool excluir = true;
				if (permissaoArquivoDigitals1.Count > 0 && permissaoArquivoDigitals1.Any<PermissaoArquivoDigital>((PermissaoArquivoDigital y) => y.get_Tela() == tipoArquivoDigital))
				{
					id = permissaoArquivoDigitals1.First<PermissaoArquivoDigital>((PermissaoArquivoDigital y) => y.get_Tela() == tipoArquivoDigital).get_Id();
					consultar = permissaoArquivoDigitals1.First<PermissaoArquivoDigital>((PermissaoArquivoDigital y) => y.get_Tela() == tipoArquivoDigital).get_Consultar();
					incluir = permissaoArquivoDigitals1.First<PermissaoArquivoDigital>((PermissaoArquivoDigital y) => y.get_Tela() == tipoArquivoDigital).get_Incluir();
					excluir = permissaoArquivoDigitals1.First<PermissaoArquivoDigital>((PermissaoArquivoDigital y) => y.get_Tela() == tipoArquivoDigital).get_Excluir();
				}
				PermissaoArquivoDigital permissaoArquivoDigital = new PermissaoArquivoDigital();
				permissaoArquivoDigital.set_Id(id);
				permissaoArquivoDigital.set_Tela(tipoArquivoDigital);
				permissaoArquivoDigital.set_Consultar(consultar);
				permissaoArquivoDigital.set_Incluir(incluir);
				permissaoArquivoDigital.set_Excluir(excluir);
				permissaoArquivoDigitals.Add(permissaoArquivoDigital);
			});
			List<PermissaoArquivoDigital> permissaoArquivoDigitals2 = permissaoArquivoDigitals;
			list = null;
			return permissaoArquivoDigitals2;
		}

		private async Task<List<RestricaoUsuario>> GetRestricoes(Usuario usuario, string modulo)
		{
			List<RestricaoUsuario> restricaoUsuarios = new List<RestricaoUsuario>();
			IEnumerable<TipoRestricao> tipoRestricaos = Enum.GetValues(typeof(TipoRestricao)).Cast<TipoRestricao>();
			IEnumerable<string> str = 
				from v in tipoRestricaos
				select v.ToString();
			List<string> list = (
				from x in str
				orderby x
				select x).ToList<string>();
			List<RestricaoUsuario> restricaoUsuarios1 = await this.ServicoRestriUsuario.BuscarRestricoes(usuario.get_Id());
			List<RestricaoUsuario> restricaoUsuarios2 = restricaoUsuarios1;
			list.ForEach((string x) => {
				TipoRestricao tipoRestricao = (TipoRestricao)Enum.Parse(typeof(TipoRestricao), x);
				if (!string.Equals(ValidationHelper.GetCategory(tipoRestricao), modulo, StringComparison.CurrentCultureIgnoreCase))
				{
					return;
				}
				string help = ValidationHelper.GetHelp(tipoRestricao);
				long id = (long)0;
				bool restricao = false;
				if (restricaoUsuarios2.Count > 0 && restricaoUsuarios2.Any<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == tipoRestricao))
				{
					id = restricaoUsuarios2.First<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == tipoRestricao).get_Id();
					restricao = restricaoUsuarios2.First<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == tipoRestricao).get_Restricao();
				}
				RestricaoUsuario restricaoUsuario = new RestricaoUsuario();
				restricaoUsuario.set_Id(id);
				restricaoUsuario.set_Tipo(tipoRestricao);
				restricaoUsuario.set_Restricao(restricao);
				restricaoUsuario.set_Ajuda(help);
				restricaoUsuarios.Add(restricaoUsuario);
			});
			List<RestricaoUsuario> restricaoUsuarios3 = restricaoUsuarios;
			list = null;
			return restricaoUsuarios3;
		}

		private async Task<List<RestricaoUsuarioCamposRelatorios>> GetRestricoesCamposRelatorios(Usuario usuario)
		{
			List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios = new List<RestricaoUsuarioCamposRelatorios>();
			List<ParametrosRelatorio> parametrosRelatorios = new List<ParametrosRelatorio>();
			foreach (Relatorio relatorio in Enum.GetValues(typeof(Relatorio)).Cast<Relatorio>())
			{
				switch (relatorio)
				{
					case 0:
					case 1:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<ClientesAtivosInativos>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 2:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Producao>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 3:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<ApolicePendente>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 4:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Renovacao>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 5:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Gestor.Model.Domain.Relatorios.Comissao.Comissao>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 6:
					case 16:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Pendente>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 7:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<DadosRelatorio>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 8:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Auditoria>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 9:
					case 10:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Sinistro>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 11:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Fechamento>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 12:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<FaturaPendente>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 13:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<ExtratoBaixadoRelatorio>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 14:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<MetaSeguradoraRelatorio>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 15:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<MetaVendedorRelatorio>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 17:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Licenciamento>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 18:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Tarefa>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 19:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<NotaFiscalRelatorio>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 20:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<PrevisaoPagamento>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 23:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<LogsEnvio>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					case 27:
					{
						parametrosRelatorios.AddRange(Funcoes.ColunasRelatorio<Placas>(relatorio, new List<ParametrosRelatorio>()));
						continue;
					}
					default:
					{
						continue;
					}
				}
			}
			List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios1 = await this.ServicoRestriUsuario.BuscarRestricoesCamposRelatorios(usuario.get_Id());
			List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios2 = restricaoUsuarioCamposRelatorios1;
			parametrosRelatorios.ForEach((ParametrosRelatorio x) => {
				long id = (long)0;
				bool restricao = false;
				if (restricaoUsuarioCamposRelatorios2.Count > 0 && restricaoUsuarioCamposRelatorios2.Any<RestricaoUsuarioCamposRelatorios>((RestricaoUsuarioCamposRelatorios y) => {
					if (y.get_Campo() != x.get_Header())
					{
						return false;
					}
					return y.get_Relatorio() == x.get_Relatorio();
				}))
				{
					id = restricaoUsuarioCamposRelatorios2.First<RestricaoUsuarioCamposRelatorios>((RestricaoUsuarioCamposRelatorios y) => {
						if (y.get_Campo() != x.get_Header())
						{
							return false;
						}
						return y.get_Relatorio() == x.get_Relatorio();
					}).get_Id();
					restricao = restricaoUsuarioCamposRelatorios2.First<RestricaoUsuarioCamposRelatorios>((RestricaoUsuarioCamposRelatorios y) => {
						if (y.get_Campo() != x.get_Header())
						{
							return false;
						}
						return y.get_Relatorio() == x.get_Relatorio();
					}).get_Restricao();
				}
				RestricaoUsuarioCamposRelatorios restricaoUsuarioCamposRelatorio = new RestricaoUsuarioCamposRelatorios();
				restricaoUsuarioCamposRelatorio.set_Id(id);
				restricaoUsuarioCamposRelatorio.set_Campo(x.get_Header());
				restricaoUsuarioCamposRelatorio.set_Relatorio(x.get_Relatorio());
				restricaoUsuarioCamposRelatorio.set_Restricao(restricao);
				restricaoUsuarioCamposRelatorios.Add(restricaoUsuarioCamposRelatorio);
			});
			List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios3 = restricaoUsuarioCamposRelatorios;
			parametrosRelatorios = null;
			return restricaoUsuarioCamposRelatorios3;
		}

		public void HabilitarArquivoDigital(PermissaoArquivoDigital habilitar)
		{
			PermissaoArquivoDigital permissaoArquivoDigital = this.ArquivosDigitais.First<PermissaoArquivoDigital>((PermissaoArquivoDigital x) => x.get_Tela() == habilitar.get_Tela());
			if (permissaoArquivoDigital.get_Consultar())
			{
				return;
			}
			permissaoArquivoDigital.set_Consultar(true);
			this.ArquivosDigitais = new ObservableCollection<PermissaoArquivoDigital>(this.ArquivosDigitais);
		}

		public void HabilitarConsulta(PermissaoUsuario habilitar, string source)
		{
			if (source != "Ferramentas")
			{
				PermissaoUsuario permissaoUsuario = this.Seguros.First<PermissaoUsuario>((PermissaoUsuario x) => x.get_Tela() == habilitar.get_Tela());
				if (permissaoUsuario.get_Consultar())
				{
					return;
				}
				permissaoUsuario.set_Consultar(true);
				this.Seguros = new ObservableCollection<PermissaoUsuario>(this.Seguros);
				return;
			}
			PermissaoUsuario permissaoUsuario1 = this.Ferramentas.First<PermissaoUsuario>((PermissaoUsuario x) => x.get_Tela() == habilitar.get_Tela());
			if (permissaoUsuario1.get_Consultar())
			{
				return;
			}
			permissaoUsuario1.set_Consultar(true);
			this.Ferramentas = new ObservableCollection<PermissaoUsuario>(this.Ferramentas);
		}

		private async Task Modulos(Usuario usuario)
		{
			Gestor.Model.Common.PermissaoAggilizador permissaoAggilizador1;
			Usuario usuario1 = usuario;
			this.Carregando = true;
			Usuario usuario2 = await this._servicoUsuario.BuscarUsuarioPorId(usuario1.get_Id());
			usuario1 = usuario2;
			this.Seguros = new ObservableCollection<PermissaoUsuario>(await this.GetPermissoes(usuario1, "seguros"));
			this.Ferramentas = new ObservableCollection<PermissaoUsuario>(await this.GetPermissoes(usuario1, "ferramentas"));
			this.ArquivosDigitais = new ObservableCollection<PermissaoArquivoDigital>(await this.GetPermissoesArquivoDigital(usuario1));
			this.PermissaoAggilizador = new List<Gestor.Model.Common.PermissaoAggilizador>((IEnumerable<!0>)await this._servicoUsuario.BuscarPermissaoAggilizador());
			this.RestricoesBis = await this.GetRestricoes(usuario1, "b.i.");
			this.RestricoesBisFiltradas = new ObservableCollection<RestricaoUsuario>(this.RestricoesBis);
			this.RestricoesSeguros = await this.GetRestricoes(usuario1, "seguros");
			this.RestricoesSegurosFiltradas = new ObservableCollection<RestricaoUsuario>(this.RestricoesSeguros);
			this.RestricoesRelatorios = await this.GetRestricoes(usuario1, "relatorios");
			this.RestricoesRelatoriosFiltrados = new ObservableCollection<RestricaoUsuario>(this.RestricoesRelatorios);
			this.RestricoesFinanceiros = await this.GetRestricoes(usuario1, "financeiro");
			this.RestricoesFinanceirosFiltradas = new ObservableCollection<RestricaoUsuario>(this.RestricoesFinanceiros);
			this.RestricoesFerramentas = await this.GetRestricoes(usuario1, "ferramentas");
			this.RestricoesFerramentasFiltradas = new ObservableCollection<RestricaoUsuario>(this.RestricoesFerramentas);
			this.RestricoesAjudas = await this.GetRestricoes(usuario1, "ajuda");
			this.RestricoesAjudasFiltrados = new ObservableCollection<RestricaoUsuario>(this.RestricoesAjudas);
			this.RestricoesTotalizacoesRelatorios = await this.GetRestricoes(usuario1, "totalizacoesRelatorios");
			this.RestricoesTotalizacoesRelatoriosFiltrados = new ObservableCollection<RestricaoUsuario>(this.RestricoesTotalizacoesRelatorios);
			this.RestricoesCamposRelatorios = await this.GetRestricoesCamposRelatorios(usuario1);
			this.RestricoesCamposRelatoriosFiltrados = new ObservableCollection<RestricaoUsuarioCamposRelatorios>(this.RestricoesCamposRelatorios);
			this.Carregando = false;
			this.AdmUsuario = usuario1.get_Administrador();
			PermissaoUsuarioViewModel permissaoUsuarioViewModel = this;
			if (!usuario1.get_PermissaoAggilizador().HasValue)
			{
				List<Gestor.Model.Common.PermissaoAggilizador> permissaoAggilizadors = this.PermissaoAggilizador;
				permissaoAggilizador1 = permissaoAggilizadors.FirstOrDefault<Gestor.Model.Common.PermissaoAggilizador>((Gestor.Model.Common.PermissaoAggilizador x) => x.get_Id() == (long)2);
			}
			else
			{
				permissaoAggilizador1 = this.PermissaoAggilizador.FirstOrDefault<Gestor.Model.Common.PermissaoAggilizador>((Gestor.Model.Common.PermissaoAggilizador x) => {
					long id = x.get_Id();
					long? permissaoAggilizador = usuario1.get_PermissaoAggilizador();
					return id == permissaoAggilizador.GetValueOrDefault() & permissaoAggilizador.HasValue;
				});
			}
			permissaoUsuarioViewModel.SelectedPermissao = permissaoAggilizador1;
		}

		public async Task<bool> Salvar(long? idUsuario = null, bool registrar = true)
		{
			bool flag;
			bool alterar;
			long num;
			long id;
			List<PermissaoUsuario> permissaoUsuarios;
			List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios;
			PermissaoUsuario permissaoUsuario1 = this.ServicoPermissUsuario.BuscarPermissao(Recursos.Usuario, 43);
			if (permissaoUsuario1 != null)
			{
				alterar = !permissaoUsuario1.get_Alterar();
			}
			else
			{
				alterar = false;
			}
			if (!alterar || Recursos.Usuario.get_Administrador())
			{
				UsuarioServico usuarioServico = this._servicoUsuario;
				long? nullable = idUsuario;
				num = (nullable.HasValue ? nullable.GetValueOrDefault() : this._selectedUsuario.get_Id());
				Usuario usuario = await usuarioServico.BuscarUsuarioPorId(num);
				List<PermissaoUsuario> permissaoUsuarios1 = new List<PermissaoUsuario>();
				List<PermissaoUsuario> permissaoUsuarios2 = permissaoUsuarios1;
				List<PermissaoUsuario> permissoes = await this.GetPermissoes(usuario, "seguros");
				permissaoUsuarios2.AddRange(permissoes);
				permissaoUsuarios2 = null;
				permissaoUsuarios2 = permissaoUsuarios1;
				permissoes = await this.GetPermissoes(usuario, "ferramentas");
				permissaoUsuarios2.AddRange(permissoes);
				permissaoUsuarios2 = null;
				List<PermissaoArquivoDigital> permissaoArquivoDigitals = new List<PermissaoArquivoDigital>();
				List<PermissaoArquivoDigital> permissaoArquivoDigitals1 = permissaoArquivoDigitals;
				permissaoArquivoDigitals1.AddRange(await this.GetPermissoesArquivoDigital(usuario));
				permissaoArquivoDigitals1 = null;
				List<PermissaoArquivoDigital> list = this.ArquivosDigitais.Select<PermissaoArquivoDigital, PermissaoArquivoDigital>((PermissaoArquivoDigital x) => {
					PermissaoArquivoDigital permissaoArquivoDigital = new PermissaoArquivoDigital();
					permissaoArquivoDigital.set_Id((permissaoArquivoDigitals.Count == 0 ? (long)0 : permissaoArquivoDigitals.First<PermissaoArquivoDigital>((PermissaoArquivoDigital y) => y.get_Tela() == x.get_Tela()).get_Id()));
					permissaoArquivoDigital.set_Tela(x.get_Tela());
					permissaoArquivoDigital.set_Consultar(x.get_Consultar());
					permissaoArquivoDigital.set_Incluir(x.get_Incluir());
					permissaoArquivoDigital.set_Excluir(x.get_Excluir());
					permissaoArquivoDigital.set_Usuario(usuario);
					return permissaoArquivoDigital;
				}).ToList<PermissaoArquivoDigital>();
				permissaoUsuarios = new List<PermissaoUsuario>();
				List<PermissaoUsuario> list1 = this.Seguros.Select<PermissaoUsuario, PermissaoUsuario>((PermissaoUsuario x) => {
					PermissaoUsuario permissaoUsuario = new PermissaoUsuario();
					permissaoUsuario.set_Id((permissaoUsuarios1.Count == 0 ? (long)0 : permissaoUsuarios1.First<PermissaoUsuario>((PermissaoUsuario y) => y.get_Tela() == x.get_Tela()).get_Id()));
					permissaoUsuario.set_Tela(x.get_Tela());
					permissaoUsuario.set_Consultar(x.get_Consultar());
					permissaoUsuario.set_Incluir(x.get_Incluir());
					permissaoUsuario.set_Alterar(x.get_Alterar());
					permissaoUsuario.set_Excluir(x.get_Excluir());
					permissaoUsuario.set_Usuario(usuario);
					return permissaoUsuario;
				}).ToList<PermissaoUsuario>();
				permissaoUsuarios.AddRange(list1);
				list1 = this.Ferramentas.Select<PermissaoUsuario, PermissaoUsuario>((PermissaoUsuario x) => {
					PermissaoUsuario permissaoUsuario = new PermissaoUsuario();
					permissaoUsuario.set_Id((permissaoUsuarios1.Count == 0 ? (long)0 : permissaoUsuarios1.First<PermissaoUsuario>((PermissaoUsuario y) => y.get_Tela() == x.get_Tela()).get_Id()));
					permissaoUsuario.set_Tela(x.get_Tela());
					permissaoUsuario.set_Consultar(x.get_Consultar());
					permissaoUsuario.set_Incluir(x.get_Incluir());
					permissaoUsuario.set_Alterar(x.get_Alterar());
					permissaoUsuario.set_Excluir(x.get_Excluir());
					permissaoUsuario.set_Usuario(usuario);
					return permissaoUsuario;
				}).ToList<PermissaoUsuario>();
				permissaoUsuarios.AddRange(list1);
				Usuario usuario1 = usuario;
				Gestor.Model.Common.PermissaoAggilizador selectedPermissao = this.SelectedPermissao;
				if (selectedPermissao != null)
				{
					id = selectedPermissao.get_Id();
				}
				else
				{
					id = (long)0;
				}
				usuario1.set_PermissaoAggilizador(new long?(id));
				usuario.set_Administrador(this.AdmUsuario);
				await this.ServicoPermissArquivoDigital.SavePermiss(list, permissaoArquivoDigitals);
				if (this.ServicoPermissArquivoDigital.Sucesso)
				{
					await this.ServicoPermissUsuario.SavePermiss(permissaoUsuarios, permissaoUsuarios1);
					if (this.ServicoPermissUsuario.Sucesso)
					{
						await this._servicoUsuario.Save(usuario);
						if (this._servicoUsuario.Sucesso)
						{
							if (Recursos.Usuario.get_Id() == this._selectedUsuario.get_Id())
							{
								Recursos.Usuario = usuario;
							}
							List<RestricaoUsuario> restricaoUsuarios = new List<RestricaoUsuario>();
							List<RestricaoUsuario> restricaoUsuarios1 = restricaoUsuarios;
							List<RestricaoUsuario> restricoes = await this.GetRestricoes(usuario, "b.i.");
							restricaoUsuarios1.AddRange(restricoes);
							restricaoUsuarios1 = null;
							restricaoUsuarios1 = restricaoUsuarios;
							restricoes = await this.GetRestricoes(usuario, "seguros");
							restricaoUsuarios1.AddRange(restricoes);
							restricaoUsuarios1 = null;
							restricaoUsuarios1 = restricaoUsuarios;
							restricoes = await this.GetRestricoes(usuario, "relatorios");
							restricaoUsuarios1.AddRange(restricoes);
							restricaoUsuarios1 = null;
							restricaoUsuarios1 = restricaoUsuarios;
							restricoes = await this.GetRestricoes(usuario, "financeiro");
							restricaoUsuarios1.AddRange(restricoes);
							restricaoUsuarios1 = null;
							restricaoUsuarios1 = restricaoUsuarios;
							restricoes = await this.GetRestricoes(usuario, "ferramentas");
							restricaoUsuarios1.AddRange(restricoes);
							restricaoUsuarios1 = null;
							restricaoUsuarios1 = restricaoUsuarios;
							restricoes = await this.GetRestricoes(usuario, "ajuda");
							restricaoUsuarios1.AddRange(restricoes);
							restricaoUsuarios1 = null;
							restricaoUsuarios1 = restricaoUsuarios;
							restricoes = await this.GetRestricoes(usuario, "totalizacoesRelatorios");
							restricaoUsuarios1.AddRange(restricoes);
							restricaoUsuarios1 = null;
							restricaoUsuarios1 = restricaoUsuarios;
							restricoes = await this.GetRestricoes(usuario, "camposRelatorios");
							restricaoUsuarios1.AddRange(restricoes);
							restricaoUsuarios1 = null;
							List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios1 = new List<RestricaoUsuarioCamposRelatorios>();
							List<RestricaoUsuarioCamposRelatorios> restricaoUsuarioCamposRelatorios2 = restricaoUsuarioCamposRelatorios1;
							restricaoUsuarioCamposRelatorios2.AddRange(await this.GetRestricoesCamposRelatorios(usuario));
							restricaoUsuarioCamposRelatorios2 = null;
							List<RestricaoUsuario> restricaoUsuarios2 = new List<RestricaoUsuario>();
							restricaoUsuarioCamposRelatorios = new List<RestricaoUsuarioCamposRelatorios>();
							List<RestricaoUsuario> list2 = this.RestricoesBis.Select<RestricaoUsuario, RestricaoUsuario>((RestricaoUsuario x) => {
								RestricaoUsuario restricaoUsuario = new RestricaoUsuario();
								restricaoUsuario.set_Id((restricaoUsuarios.Count == 0 ? (long)0 : restricaoUsuarios.First<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == x.get_Tipo()).get_Id()));
								restricaoUsuario.set_Tipo(x.get_Tipo());
								restricaoUsuario.set_Restricao(x.get_Restricao());
								restricaoUsuario.set_Usuario(usuario);
								return restricaoUsuario;
							}).ToList<RestricaoUsuario>();
							restricaoUsuarios2.AddRange(list2);
							list2 = this.RestricoesSeguros.Select<RestricaoUsuario, RestricaoUsuario>((RestricaoUsuario x) => {
								RestricaoUsuario restricaoUsuario = new RestricaoUsuario();
								restricaoUsuario.set_Id((restricaoUsuarios.Count == 0 ? (long)0 : restricaoUsuarios.First<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == x.get_Tipo()).get_Id()));
								restricaoUsuario.set_Tipo(x.get_Tipo());
								restricaoUsuario.set_Restricao(x.get_Restricao());
								restricaoUsuario.set_Usuario(usuario);
								return restricaoUsuario;
							}).ToList<RestricaoUsuario>();
							restricaoUsuarios2.AddRange(list2);
							list2 = this.RestricoesRelatorios.Select<RestricaoUsuario, RestricaoUsuario>((RestricaoUsuario x) => {
								RestricaoUsuario restricaoUsuario = new RestricaoUsuario();
								restricaoUsuario.set_Id((restricaoUsuarios.Count == 0 ? (long)0 : restricaoUsuarios.First<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == x.get_Tipo()).get_Id()));
								restricaoUsuario.set_Tipo(x.get_Tipo());
								restricaoUsuario.set_Restricao(x.get_Restricao());
								restricaoUsuario.set_Usuario(usuario);
								return restricaoUsuario;
							}).ToList<RestricaoUsuario>();
							restricaoUsuarios2.AddRange(list2);
							list2 = this.RestricoesTotalizacoesRelatorios.Select<RestricaoUsuario, RestricaoUsuario>((RestricaoUsuario x) => {
								RestricaoUsuario restricaoUsuario = new RestricaoUsuario();
								restricaoUsuario.set_Id((restricaoUsuarios.Count == 0 ? (long)0 : restricaoUsuarios.First<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == x.get_Tipo()).get_Id()));
								restricaoUsuario.set_Tipo(x.get_Tipo());
								restricaoUsuario.set_Restricao(x.get_Restricao());
								restricaoUsuario.set_Usuario(usuario);
								return restricaoUsuario;
							}).ToList<RestricaoUsuario>();
							restricaoUsuarios2.AddRange(list2);
							list2 = this.RestricoesFinanceiros.Select<RestricaoUsuario, RestricaoUsuario>((RestricaoUsuario x) => {
								RestricaoUsuario restricaoUsuario = new RestricaoUsuario();
								restricaoUsuario.set_Id((restricaoUsuarios.Count == 0 ? (long)0 : restricaoUsuarios.First<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == x.get_Tipo()).get_Id()));
								restricaoUsuario.set_Tipo(x.get_Tipo());
								restricaoUsuario.set_Restricao(x.get_Restricao());
								restricaoUsuario.set_Usuario(usuario);
								return restricaoUsuario;
							}).ToList<RestricaoUsuario>();
							restricaoUsuarios2.AddRange(list2);
							list2 = this.RestricoesFerramentas.Select<RestricaoUsuario, RestricaoUsuario>((RestricaoUsuario x) => {
								RestricaoUsuario restricaoUsuario = new RestricaoUsuario();
								restricaoUsuario.set_Id((restricaoUsuarios.Count == 0 ? (long)0 : restricaoUsuarios.First<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == x.get_Tipo()).get_Id()));
								restricaoUsuario.set_Tipo(x.get_Tipo());
								restricaoUsuario.set_Restricao(x.get_Restricao());
								restricaoUsuario.set_Usuario(usuario);
								return restricaoUsuario;
							}).ToList<RestricaoUsuario>();
							restricaoUsuarios2.AddRange(list2);
							list2 = this.RestricoesAjudas.Select<RestricaoUsuario, RestricaoUsuario>((RestricaoUsuario x) => {
								RestricaoUsuario restricaoUsuario = new RestricaoUsuario();
								restricaoUsuario.set_Id((restricaoUsuarios.Count == 0 ? (long)0 : restricaoUsuarios.First<RestricaoUsuario>((RestricaoUsuario y) => y.get_Tipo() == x.get_Tipo()).get_Id()));
								restricaoUsuario.set_Tipo(x.get_Tipo());
								restricaoUsuario.set_Restricao(x.get_Restricao());
								restricaoUsuario.set_Usuario(usuario);
								return restricaoUsuario;
							}).ToList<RestricaoUsuario>();
							restricaoUsuarios2.AddRange(list2);
							List<RestricaoUsuarioCamposRelatorios> list3 = this.RestricoesCamposRelatorios.Select<RestricaoUsuarioCamposRelatorios, RestricaoUsuarioCamposRelatorios>((RestricaoUsuarioCamposRelatorios x) => {
								RestricaoUsuarioCamposRelatorios restricaoUsuarioCamposRelatorio = new RestricaoUsuarioCamposRelatorios();
								restricaoUsuarioCamposRelatorio.set_Id((restricaoUsuarioCamposRelatorios1.Count == 0 ? (long)0 : restricaoUsuarioCamposRelatorios1.First<RestricaoUsuarioCamposRelatorios>((RestricaoUsuarioCamposRelatorios y) => {
									if (y.get_Campo() != x.get_Campo())
									{
										return false;
									}
									return y.get_Relatorio() == x.get_Relatorio();
								}).get_Id()));
								restricaoUsuarioCamposRelatorio.set_Campo(x.get_Campo());
								restricaoUsuarioCamposRelatorio.set_Restricao(x.get_Restricao());
								restricaoUsuarioCamposRelatorio.set_Relatorio(x.get_Relatorio());
								restricaoUsuarioCamposRelatorio.set_Usuario(usuario);
								return restricaoUsuarioCamposRelatorio;
							}).ToList<RestricaoUsuarioCamposRelatorios>();
							restricaoUsuarioCamposRelatorios.AddRange(list3);
							await this.ServicoRestriUsuario.SaveRestri(restricaoUsuarios2, restricaoUsuarios);
							if (this.ServicoRestriUsuario.Sucesso)
							{
								await this.ServicoRestriUsuario.SaveRestriCamposRelatorios(restricaoUsuarioCamposRelatorios, restricaoUsuarioCamposRelatorios1);
								if (this.ServicoRestriUsuario.Sucesso)
								{
									if (registrar)
									{
										base.RegistrarAcao(string.Concat("ALTEROU PERMISSÕES/RESTRIÇÕES DO USUÁRIO \"", this.SelectedUsuario.get_Nome(), "\""), this.SelectedUsuario.get_Id(), new TipoTela?(43), "ACESSE O LOG DE ALTERAÇÕES NA TELA DE PERMISSÕES/RESTRIÇÕES PARA VER EXATAMENTE O QUE FOI ALTERADO.");
									}
									flag = true;
								}
								else
								{
									flag = false;
								}
							}
							else
							{
								flag = false;
							}
						}
						else
						{
							flag = false;
						}
					}
					else
					{
						flag = false;
					}
				}
				else
				{
					flag = false;
				}
			}
			else
			{
				await base.ShowMessage("VOCÊ NÃO TEM PERMISSÃO PARA ALTERAR PERMISSÕES!", "OK", "", false);
				flag = false;
			}
			permissaoUsuarios = null;
			restricaoUsuarioCamposRelatorios = null;
			return flag;
		}
	}
}