diff options
Diffstat (limited to 'Decompiler/Gestor.Application.ViewModels.Drawer/PermissaoUsuarioViewModel.cs')
| -rw-r--r-- | Decompiler/Gestor.Application.ViewModels.Drawer/PermissaoUsuarioViewModel.cs | 1704 |
1 files changed, 1704 insertions, 0 deletions
diff --git a/Decompiler/Gestor.Application.ViewModels.Drawer/PermissaoUsuarioViewModel.cs b/Decompiler/Gestor.Application.ViewModels.Drawer/PermissaoUsuarioViewModel.cs new file mode 100644 index 0000000..393faa6 --- /dev/null +++ b/Decompiler/Gestor.Application.ViewModels.Drawer/PermissaoUsuarioViewModel.cs @@ -0,0 +1,1704 @@ +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); + } + } + } +} |