decompiler.com

1 files changed, 684 insertions, 0 deletions

diff --git a/Decompiler/Gestor.Application.ViewModels.Ferramentas/UsuarioViewModel.cs b/Decompiler/Gestor.Application.ViewModels.Ferramentas/UsuarioViewModel.cs
new file mode 100644
index 0000000..f8f20d8
--- /dev/null
+++ b/Decompiler/Gestor.Application.ViewModels.Ferramentas/UsuarioViewModel.cs
@@ -0,0 +1,684 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using Agger.Registro;
+using Gestor.Application.Actions;
+using Gestor.Application.Drawers;
+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.Helpers;
+using Gestor.Common.Security;
+using Gestor.Common.Validation;
+using Gestor.Model.API;
+using Gestor.Model.Common;
+using Gestor.Model.Domain.Common;
+using Gestor.Model.Domain.Generic;
+using Gestor.Model.Domain.Seguros;
+using MaterialDesignThemes.Wpf;
+using Newtonsoft.Json;
+
+namespace Gestor.Application.ViewModels.Ferramentas;
+
+public class UsuarioViewModel : BaseSegurosViewModel
+{
+	private readonly UsuarioServico _servico;
+
+	private readonly PermissaoUsuarioServico _permissaoUsuarioServico;
+
+	public Usuario CancelUsuario;
+
+	private string _inicioAcesso;
+
+	private string _fimAcesso;
+
+	private Usuario _selectedUsuario;
+
+	private Empresa _selectedFilial;
+
+	private bool _cartaoCriado;
+
+	private ObservableCollection<Usuario> _usuariosFiltrados = new ObservableCollection<Usuario>();
+
+	private bool _isExpanded;
+
+	private bool _enableGrid = true;
+
+	private Visibility _horarioAcessoVisible;
+
+	private List<Empresa> _empresas = Recursos.Empresas;
+
+	private string _confirmaSenha;
+
+	private string _labelCartao;
+
+	public static DrawerHost Drawer { get; set; }
+
+	public List<PermissaoUsuario> PermissaoUsuario { get; set; }
+
+	public List<Usuario> Usuarios { get; set; }
+
+	public string InicioAcesso
+	{
+		get
+		{
+			return _inicioAcesso;
+		}
+		set
+		{
+			_inicioAcesso = value;
+			OnPropertyChanged("InicioAcesso");
+		}
+	}
+
+	public string FimAcesso
+	{
+		get
+		{
+			return _fimAcesso;
+		}
+		set
+		{
+			_fimAcesso = value;
+			OnPropertyChanged("FimAcesso");
+		}
+	}
+
+	public Usuario SelectedUsuario
+	{
+		get
+		{
+			return _selectedUsuario;
+		}
+		set
+		{
+			_selectedUsuario = value;
+			WorkOnSelectedUsuario(value);
+			VerificarEnables((value != null) ? new long?(((DomainBase)value).Id) : null);
+			OnPropertyChanged("SelectedUsuario");
+		}
+	}
+
+	public Empresa SelectedFilial
+	{
+		get
+		{
+			return _selectedFilial;
+		}
+		set
+		{
+			_selectedFilial = value;
+			OnPropertyChanged("SelectedFilial");
+		}
+	}
+
+	public bool CartaoCriado
+	{
+		get
+		{
+			return _cartaoCriado;
+		}
+		set
+		{
+			_cartaoCriado = value;
+			OnPropertyChanged("CartaoCriado");
+		}
+	}
+
+	public ObservableCollection<Usuario> UsuariosFiltrados
+	{
+		get
+		{
+			return _usuariosFiltrados;
+		}
+		set
+		{
+			_usuariosFiltrados = value;
+			IsExpanded = value != null && value.Count > 0;
+			OnPropertyChanged("UsuariosFiltrados");
+		}
+	}
+
+	public bool IsExpanded
+	{
+		get
+		{
+			return _isExpanded;
+		}
+		set
+		{
+			_isExpanded = value;
+			OnPropertyChanged("IsExpanded");
+		}
+	}
+
+	public bool EnableGrid
+	{
+		get
+		{
+			return _enableGrid;
+		}
+		set
+		{
+			_enableGrid = value;
+			OnPropertyChanged("EnableGrid");
+		}
+	}
+
+	public Visibility HorarioAcessoVisible
+	{
+		get
+		{
+			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
+			return _horarioAcessoVisible;
+		}
+		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)
+			_horarioAcessoVisible = value;
+			OnPropertyChanged("HorarioAcessoVisible");
+		}
+	}
+
+	public List<Empresa> Empresas
+	{
+		get
+		{
+			return _empresas;
+		}
+		set
+		{
+			_empresas = value;
+			OnPropertyChanged("Empresas");
+		}
+	}
+
+	public Visibility AddUsuarioCentralSeguradoVisibility { get; set; } = (Visibility)(string.IsNullOrEmpty(Connection.UrlCentralSegurado) ? 2 : 0);
+
+
+	private string SenhaOriginal { get; set; }
+
+	public string ConfirmaSenha
+	{
+		get
+		{
+			return _confirmaSenha;
+		}
+		set
+		{
+			_confirmaSenha = value;
+			OnPropertyChanged("ConfirmaSenha");
+		}
+	}
+
+	public string LabelCartao
+	{
+		get
+		{
+			return _labelCartao;
+		}
+		set
+		{
+			_labelCartao = value;
+			OnPropertyChanged("LabelCartao");
+		}
+	}
+
+	public UsuarioViewModel()
+	{
+		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
+		_servico = new UsuarioServico();
+		_permissaoUsuarioServico = new PermissaoUsuarioServico();
+		base.EnableMenu = true;
+	}
+
+	private async Task BuscaPermissao()
+	{
+		PermissaoUsuario = await _permissaoUsuarioServico.PermissUsuario(Recursos.Usuario);
+	}
+
+	public async Task Seleciona()
+	{
+		HorarioAcessoVisible = (Visibility)(Restricao((TipoRestricao)94) ? 2 : 0);
+		await PermissaoTela((TipoTela)16);
+		await SelecionaUsuarios();
+	}
+
+	public async Task VerificaUsuarioAdmCentralSegurado()
+	{
+		await BuscaAlteracaoUsuarios(((DomainBase)SelectedUsuario).Id);
+	}
+
+	private async Task CarregarUsuarios()
+	{
+		Usuarios = (from x in await new BaseServico().CarregarUsuarios()
+			where !x.Excluido && x.PermissaoAggilizador != 4
+			orderby x.Nome
+			select x).ToList();
+		UsuariosFiltrados = new ObservableCollection<Usuario>(Usuarios);
+		await BuscaPermissao();
+	}
+
+	private async Task SelecionaUsuarios()
+	{
+		EnableGrid = false;
+		Loading(isLoading: true);
+		await CarregarUsuarios();
+		if (UsuariosFiltrados.Count > 0)
+		{
+			await SelecionaUsuario(UsuariosFiltrados.First());
+		}
+		else
+		{
+			SelectedUsuario = new Usuario
+			{
+				Segunda = true,
+				Terca = true,
+				Quarta = true,
+				Quinta = true,
+				Sexta = true,
+				Sabado = true,
+				Domingo = true
+			};
+			Alterar(alterar: false);
+			base.EnableMenu = false;
+		}
+		Loading(isLoading: false);
+		EnableGrid = true;
+	}
+
+	public async Task<List<KeyValuePair<string, string>>> Validate()
+	{
+		List<KeyValuePair<string, string>> errors = new List<KeyValuePair<string, string>>();
+		if (SenhaOriginal == null || SenhaOriginal != SelectedUsuario.Senha)
+		{
+			string b = new Token().Decrypt(SelectedUsuario.Senha) ?? SelectedUsuario.Senha;
+			if (string.IsNullOrWhiteSpace(ConfirmaSenha))
+			{
+				errors.Add(new KeyValuePair<string, string>("ConfirmaSenha|CONFIRMAÇÃO SENHA", "OBRIGATÓRIO"));
+			}
+			else if (!string.Equals(ConfirmaSenha, b))
+			{
+				errors.Add(new KeyValuePair<string, string>("ConfirmaSenha|CONFIRMAÇÃO SENHA", "INVÁLIDO"));
+			}
+		}
+		List<Usuario> list = (string.IsNullOrWhiteSpace(SelectedUsuario.Login) ? new List<Usuario>() : (await new BaseServico().BuscarUsuarioPorLoginInteiro(SelectedUsuario.Login)));
+		foreach (Usuario item in list)
+		{
+			if (((DomainBase)item).Id != ((DomainBase)SelectedUsuario).Id)
+			{
+				errors.Add(new KeyValuePair<string, string>("Login", "O LOGIN JÁ ESTÁ CADASTRADO PARA O USUÁRIO \"" + item.Nome + "\"."));
+			}
+		}
+		if (SelectedUsuario.InicioAcesso.HasValue && !SelectedUsuario.FimAcesso.HasValue)
+		{
+			errors.Add(new KeyValuePair<string, string>("FIM DO ACESSO", "NECESSÁRIO PREENCHER O CAMPO FIM DO ACESSO!"));
+		}
+		if (!SelectedUsuario.InicioAcesso.HasValue && SelectedUsuario.FimAcesso.HasValue)
+		{
+			errors.Add(new KeyValuePair<string, string>("INÍCIO DO ACESSO", "NECESSÁRIO PREENCHER O CAMPO INÍCIO DO ACESSO!"));
+		}
+		bool flag = !string.IsNullOrWhiteSpace(SelectedUsuario.Documento);
+		if (flag)
+		{
+			flag = await new BaseServico().BuscarUsuarioMesmoDocumento(ValidationHelper.OnlyNumber(SelectedUsuario.Documento), ((DomainBase)SelectedUsuario).Id, SelectedUsuario.IdEmpresa);
+		}
+		if (flag)
+		{
+			errors.Add(new KeyValuePair<string, string>("Documento", "O DOCUMENTO JÁ ESTÁ SENDO USADO EM OUTRO USUÁRIO"));
+		}
+		return errors;
+	}
+
+	public void Incluir()
+	{
+		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0016: 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_002e: Unknown result type (might be due to invalid IL or missing references)
+		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
+		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
+		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0082: Expected O, but got Unknown
+		SelectedUsuario = new Usuario
+		{
+			IdEmpresa = Recursos.Usuario.IdEmpresa,
+			Segunda = true,
+			Terca = true,
+			Quarta = true,
+			Quinta = true,
+			Sexta = true,
+			Sabado = true,
+			Domingo = true,
+			Excluido = false,
+			FiltroInicial = (TipoFiltroCliente)0
+		};
+		SenhaOriginal = null;
+		Alterar(alterar: true);
+	}
+
+	public async Task<List<KeyValuePair<string, string>>> Salvar()
+	{
+		if (DateTime.TryParse(InicioAcesso, out var result) && DateTime.TryParse(FimAcesso, out var result2))
+		{
+			SelectedUsuario.InicioAcesso = result;
+			SelectedUsuario.FimAcesso = result2;
+		}
+		else
+		{
+			SelectedUsuario.InicioAcesso = null;
+			SelectedUsuario.FimAcesso = null;
+		}
+		SelectedUsuario.Senha = ((!string.IsNullOrEmpty(SelectedUsuario.Senha)) ? SelectedUsuario.Senha : SenhaOriginal);
+		List<KeyValuePair<string, string>> errorMessages = SelectedUsuario.Validate();
+		List<KeyValuePair<string, string>> list = errorMessages;
+		list.AddRange(await Validate());
+		if (errorMessages.Count > 0)
+		{
+			return errorMessages;
+		}
+		SelectedUsuario.Senha = new Token().AggerEncrypt(SelectedUsuario.Senha);
+		SelectedUsuario.IdEmpresa = ((SelectedUsuario.IdEmpresa == 0L) ? Recursos.Usuario.IdEmpresa : SelectedUsuario.IdEmpresa);
+		bool usuarioAlterado = await BuscaAlteracaoUsuarios(((DomainBase)SelectedUsuario).Id);
+		string acao = ((((DomainBase)SelectedUsuario).Id == 0L) ? "INCLUIU" : "ALTEROU");
+		Usuario value = await _servico.Save(SelectedUsuario);
+		if (!_servico.Sucesso)
+		{
+			return null;
+		}
+		RegistrarAcao(acao + " USUÁRIO \"" + value.Nome + "\"", ((DomainBase)value).Id, (TipoTela)16, $"ID: {((DomainBase)value).Id}");
+		if (usuarioAlterado)
+		{
+			await AddUsuarioAdiministadorCentralSegurado();
+		}
+		await CarregarUsuarios();
+		SelectedUsuario = ((IEnumerable<Usuario>)UsuariosFiltrados).FirstOrDefault((Func<Usuario, bool>)((Usuario x) => ((DomainBase)x).Id == ((DomainBase)value).Id));
+		Recursos.Usuarios = Usuarios;
+		ConfirmaSenha = "";
+		Alterar(alterar: false);
+		ToggleSnackBar("USUÁRIO SALVO COM SUCESSO");
+		IsExpanded = true;
+		return null;
+	}
+
+	public async Task CancelarAlteracao()
+	{
+		await CarregarUsuarios();
+		if (UsuariosFiltrados.Any())
+		{
+			Usuario cancelUsuario = CancelUsuario;
+			long id = ((cancelUsuario != null) ? ((DomainBase)cancelUsuario).Id : 0);
+			SelectedUsuario = ((IEnumerable<Usuario>)UsuariosFiltrados).FirstOrDefault((Func<Usuario, bool>)((Usuario x) => ((DomainBase)x).Id == id));
+		}
+		else
+		{
+			SelectedUsuario = new Usuario();
+			Alterar(alterar: false);
+			base.EnableMenu = false;
+		}
+		Alterar(alterar: false);
+		ConfirmaSenha = "";
+	}
+
+	public async Task Excluir()
+	{
+		if (SelectedUsuario == null || ((DomainBase)SelectedUsuario).Id == 0L)
+		{
+			return;
+		}
+		if (await new VendedorUsuarioServico().FindVinculoByUsuario(((DomainBase)SelectedUsuario).Id))
+		{
+			await ShowMessage("O USUÁRIO POSSUI VÍNCULO DE VENDEDOR, REMOVA O VÍNCULO ANTES DE EXCLUIR.");
+		}
+		else
+		{
+			if (!(await ShowMessage("DESEJA EXCLUIR?", "SIM", "NÃO")))
+			{
+				return;
+			}
+			Loading(isLoading: true);
+			if (!(await _servico.Delete(SelectedUsuario)))
+			{
+				Loading(isLoading: false);
+				return;
+			}
+			RegistrarAcao("EXCLUIU USUÁRIO \"" + SelectedUsuario.Nome + "\"", ((DomainBase)SelectedUsuario).Id, (TipoTela)16, $"ID: {((DomainBase)SelectedUsuario).Id}");
+			await CarregarUsuarios();
+			if (UsuariosFiltrados.Any())
+			{
+				SelectedUsuario = UsuariosFiltrados.FirstOrDefault();
+			}
+			else
+			{
+				SelectedUsuario = new Usuario();
+				Alterar(alterar: false);
+				base.EnableMenu = false;
+			}
+			Loading(isLoading: false);
+			ToggleSnackBar("USUÁRIO EXCLUÍDO COM SUCESSO");
+		}
+	}
+
+	internal async Task<List<Usuario>> Filtrar(string value)
+	{
+		return await Task.Run(() => FiltrarUsuario(value));
+	}
+
+	public List<Usuario> FiltrarUsuario(string filter)
+	{
+		UsuariosFiltrados = (string.IsNullOrWhiteSpace(filter) ? new ObservableCollection<Usuario>(Usuarios) : new ObservableCollection<Usuario>(from x in Usuarios
+			where ValidationHelper.RemoveDiacritics(x.Nome.Trim()).ToUpper().Contains(ValidationHelper.RemoveDiacritics(filter))
+			orderby !x.Excluido descending, x.Nome
+			select x));
+		return UsuariosFiltrados.ToList();
+	}
+
+	public async Task SelecionaUsuario(Usuario usuario)
+	{
+		Usuario val = await _servico.BuscarUsuarioPorId(((DomainBase)usuario).Id);
+		val.Segunda = val.Segunda.GetValueOrDefault(true);
+		val.Terca = val.Terca.GetValueOrDefault(true);
+		val.Quarta = val.Quarta.GetValueOrDefault(true);
+		val.Quinta = val.Quinta.GetValueOrDefault(true);
+		val.Sexta = val.Sexta.GetValueOrDefault(true);
+		val.Sabado = val.Sabado.GetValueOrDefault(true);
+		val.Domingo = val.Domingo.GetValueOrDefault(true);
+		if (((DomainBase)Recursos.Usuario).Id == ((DomainBase)usuario).Id)
+		{
+			val.Senha = new Token().AggerDecrypt(val.Senha);
+			SenhaOriginal = val.Senha;
+			ConfirmaSenha = "";
+			DomainBase.Copy<Usuario, Usuario>(UsuariosFiltrados.First((Usuario x) => ((DomainBase)x).Id == ((DomainBase)usuario).Id), val);
+		}
+		SelectedUsuario = UsuariosFiltrados.First((Usuario x) => ((DomainBase)x).Id == ((DomainBase)usuario).Id);
+	}
+
+	public async Task OpenPermissao()
+	{
+		bool flag = SelectedUsuario == null;
+		if (flag)
+		{
+			flag = await ShowMessage("É NECESSÁRIO SELECIONAR UM USUÁRIO!");
+		}
+		if (!flag)
+		{
+			Gestor.Application.Actions.Actions.AtualizaUsuario = (Action)Delegate.Remove(Gestor.Application.Actions.Actions.AtualizaUsuario, new Action(AtualizaUsuario));
+			Gestor.Application.Actions.Actions.AtualizaUsuario = (Action)Delegate.Combine(Gestor.Application.Actions.Actions.AtualizaUsuario, new Action(AtualizaUsuario));
+			ShowDrawer(new PermissaoUsuarioDrawer(SelectedUsuario), 0, close: false);
+		}
+	}
+
+	public async void AtualizaUsuario()
+	{
+		if (!base.EnableFields)
+		{
+			await CarregarUsuarios();
+		}
+	}
+
+	public async Task OpenVinculo()
+	{
+		bool flag = SelectedUsuario == null;
+		if (flag)
+		{
+			flag = await ShowMessage("É NECESSÁRIO SELECIONAR UM USUÁRIO!");
+		}
+		if (!flag)
+		{
+			ShowDrawer(new VinculoVendedorDrawer(SelectedUsuario), 0);
+		}
+	}
+
+	private void WorkOnSelectedUsuario(Usuario value, bool registrar = true)
+	{
+		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
+		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
+		//IL_0093: Invalid comparison between Unknown and I4
+		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
+		CartaoCriado = false;
+		CancelUsuario = (Usuario)((value == null || ((DomainBase)value).Id == 0L) ? ((object)CancelUsuario) : ((object)(Usuario)((DomainBase)value).Clone()));
+		if (value == null || ((DomainBase)value).Id == 0L)
+		{
+			return;
+		}
+		value.Senha = EncryptionHelper.Decrypt(value.Senha);
+		if (LastAccessId == ((DomainBase)value).Id && (int)LastAccessTela == 16)
+		{
+			return;
+		}
+		if (registrar)
+		{
+			RegistrarAcao("ACESSOU USUÁRIO \"" + value.Nome + "\"", ((DomainBase)value).Id, (TipoTela)16, $"ID USUÁRIO: {((DomainBase)value).Id}");
+		}
+		LastAccessId = ((DomainBase)value).Id;
+		LastAccessTela = (TipoTela)16;
+		Usuario selectedUsuario = SelectedUsuario;
+		if (((selectedUsuario != null) ? new long?(((DomainBase)selectedUsuario).Id) : null) != ((DomainBase)value).Id)
+		{
+			SelectedUsuario = ((IEnumerable<Usuario>)UsuariosFiltrados).FirstOrDefault((Func<Usuario, bool>)((Usuario x) => ((DomainBase)x).Id == ((DomainBase)value).Id));
+		}
+		if (SelectedUsuario.InicioAcesso.HasValue && SelectedUsuario.FimAcesso.HasValue)
+		{
+			InicioAcesso = SelectedUsuario.InicioAcesso.Value.ToString("HH:mm");
+			FimAcesso = SelectedUsuario.FimAcesso.Value.ToString("HH:mm");
+		}
+		if (!SelectedUsuario.InicioAcesso.HasValue && !SelectedUsuario.FimAcesso.HasValue)
+		{
+			InicioAcesso = null;
+			FimAcesso = null;
+		}
+		CartaoCriado = !string.IsNullOrEmpty(value.Visita);
+		LabelCartao = (CartaoCriado ? "ATUALIZAR CARTÃO" : "CRIAR CARTÃO");
+	}
+
+	public async Task CriarCartao(bool dadosUsuario)
+	{
+		await ShowMessage("CARTÃO CRIADO/ATUALIZADO COM SUCESSO");
+	}
+
+	public async Task AlterarUsuario()
+	{
+		if (SelectedUsuario != null)
+		{
+			Usuario val = await _servico.BuscarUsuarioPorId(((DomainBase)SelectedUsuario).Id);
+			SenhaOriginal = new Token().AggerDecrypt(val.Senha);
+			await SelecionaUsuario(SelectedUsuario);
+		}
+	}
+
+	private async Task<bool> BuscaAlteracaoUsuarios(long idUsuario)
+	{
+		Usuario val = await new UsuarioServico().BuscarUsuarioPorId(idUsuario);
+		bool usuarioAlteradoADMCentral = val != null && ((val != null) ? new bool?(val.AdministradorCentralSegurado) : null) != SelectedUsuario.AdministradorCentralSegurado;
+		bool novoUsuarioADMCentral = !usuarioAlteradoADMCentral && SelectedUsuario.AdministradorCentralSegurado && ((DomainBase)SelectedUsuario).Id == 0;
+		List<Usuario> list = (from x in Usuarios
+			where x.AdministradorCentralSegurado
+			orderby x.Nome
+			select x).ToList();
+		if (usuarioAlteradoADMCentral && !novoUsuarioADMCentral && list.Count == 0 && !(await ShowMessage("ESTE USUÁRIO É O ÚNICO ADM DA CENTRAL DO SEGURADO.\nTEM CERTEZA QUE DESEJA REMOVER?", "SIM", "CANCELAR")))
+		{
+			CancelarAlteracao();
+			return false;
+		}
+		if ((novoUsuarioADMCentral || usuarioAlteradoADMCentral) && string.IsNullOrEmpty(Connection.UrlCentralSegurado))
+		{
+			if (SelectedUsuario != null)
+			{
+				SelectedUsuario.AdministradorCentralSegurado = false;
+			}
+			await ShowMessage("NÃO FOI POSSÍVEL ADICIONAR UM USUÁRIO ADM CENTRAL SEGURADO, POR FAVOR ENTRE EM CONTATO COM O SUPORTE AGGER. \nURL AUSENTE!");
+			return false;
+		}
+		return usuarioAlteradoADMCentral || novoUsuarioADMCentral;
+	}
+
+	public async Task AddUsuarioAdiministadorCentralSegurado()
+	{
+		if (SelectedUsuario == null)
+		{
+			return;
+		}
+		Loading(isLoading: true);
+		string message = "USUÁRIO CADASTRADO/ALTERADO COM SUCESSO!";
+		try
+		{
+			string text = ((SelectedUsuario.Telefone == null) ? string.Empty : ("(" + SelectedUsuario.Prefixo + ") " + SelectedUsuario.Telefone));
+			Token val = new Token();
+			UsuarioCentralSegurado val2 = new UsuarioCentralSegurado
+			{
+				Id = "",
+				Senha = "",
+				Serial = val.Encrypt(Recursos.Empresa.Serial),
+				FornecedorId = ApplicationHelper.IdFornecedor,
+				Nome = val.Encrypt(SelectedUsuario.Nome),
+				Documento = val.Encrypt(SelectedUsuario.Documento.Clear()),
+				Email = val.Encrypt(SelectedUsuario.Email),
+				IdEmpresa = SelectedUsuario.IdEmpresa,
+				Telefone = val.Encrypt(text),
+				Rua = ((((EnderecoBase)SelectedUsuario).Cidade != null) ? val.Encrypt(((EnderecoBase)SelectedUsuario).Endereco) : string.Empty),
+				Numero = ((((EnderecoBase)SelectedUsuario).Cidade != null) ? val.Encrypt(((EnderecoBase)SelectedUsuario).Numero) : string.Empty),
+				Bairro = ((((EnderecoBase)SelectedUsuario).Cidade != null) ? val.Encrypt(((EnderecoBase)SelectedUsuario).Bairro) : string.Empty),
+				Cidade = ((((EnderecoBase)SelectedUsuario).Cidade != null) ? val.Encrypt(((EnderecoBase)SelectedUsuario).Cidade) : string.Empty),
+				Estado = ((((EnderecoBase)SelectedUsuario).Cidade != null) ? val.Encrypt(((EnderecoBase)SelectedUsuario).Estado) : string.Empty),
+				Cep = ((((EnderecoBase)SelectedUsuario).Cidade != null) ? val.Encrypt(((EnderecoBase)SelectedUsuario).Cep) : string.Empty),
+				Corretora = val.Encrypt(Recursos.Empresa.Nome),
+				UriCorretora = val.Encrypt(Connection.UrlCentralSegurado),
+				Admin = SelectedUsuario.AdministradorCentralSegurado
+			};
+			HttpClient client = new HttpClient();
+			try
+			{
+				StringContent val3 = new StringContent(JsonConvert.SerializeObject((object)val2), Encoding.UTF8, "application/json");
+				Uri uri = Address.CentralSegurado.Append("Usuario").Append("AddAggerApp");
+				HttpResponseMessage response = await client.PostAsync(uri, (HttpContent)(object)val3);
+				await _servico.AddCentralSegurado(((DomainBase)SelectedUsuario).Id, response.IsSuccessStatusCode);
+				if (!response.IsSuccessStatusCode)
+				{
+					message = "HOUVE(RAM) O(S) SEGUINTE(S) ERROS: " + (await response.Content.ReadAsStringAsync()).Replace(";", ", ").ToUpper();
+				}
+			}
+			finally
+			{
+				((IDisposable)client)?.Dispose();
+			}
+		}
+		catch
+		{
+			message = "HOUVERAM ERROS AO CADASTRAR/ALTERAR O USUÁRIO!";
+		}
+		Loading(isLoading: false);
+		await ShowMessage(message);
+	}
+}