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);
	}
}