public static async Task <bool> ChangeBackgroundColorTo(this View self, Color newColor, uint length = 250, Easing easing = null)
{
var retorno = new Task <bool>(() => false);
if (self == null)
{
await Estrutura.Mensagem($"Não foi possível trocar a cor de fundo no método {nameof(ChangeBackgroundColorTo)} porque o parâmetro essencial do tipo {typeof(View)} chamado {nameof(self)} está nulo").ConfigureAwait(false);
return(false);
}
if (!self.AnimationIsRunning(nameof(ChangeBackgroundColorTo)))
{
var fromColor = self.BackgroundColor;
try
{
Color Transform(double x) =>
Color.FromRgba(fromColor.R + x * (newColor.R - fromColor.R),
fromColor.G + x * (newColor.G - fromColor.G),
fromColor.B + x * (newColor.B - fromColor.B),
fromColor.A + x * (newColor.A - fromColor.A));
retorno = TransmuteColorAnimation(self, nameof(ChangeBackgroundColorTo), Transform, length, easing);
}
catch (Exception ex)
{
await Estrutura.Mensagem(ex.Message).ConfigureAwait(false);
self.BackgroundColor = fromColor;
}
}
return(await retorno.ConfigureAwait(false));
}
public static async Task <List <_ComponenteBase> > VerificarPreenchimentoCampos(this List <_ComponenteBase> listaCampos, bool mostrarMensagem = true, Dictionary <_ComponenteBase, Func <bool> > camposValores = null)
{
var camposAdicionais = camposValores?.Where(x => x.Value?.Invoke() ?? false).Select(x => x.Key).ToList() ?? new List <_ComponenteBase>();
var camposRemovidos = camposValores?.Where(x => !x.Value?.Invoke() ?? true).Select(x => x.Key).ToList() ?? new List <_ComponenteBase>();
var listaCamposTratado = listaCampos?.Where(x => !camposRemovidos.Contains(x)).Union(camposAdicionais).ToList() ?? new List <_ComponenteBase>();
var camposNaoPreenchidos = new List <_ComponenteBase>();
camposNaoPreenchidos.AddRange(listaCamposTratado.OfType <Entrada>().Where(x => string.IsNullOrEmpty(x.Texto)).ToList());
camposNaoPreenchidos.AddRange(listaCamposTratado.OfType <EntradaAdicional>().Where(x => string.IsNullOrEmpty(x.Texto)).ToList());
camposNaoPreenchidos.AddRange(listaCamposTratado.OfType <MostraValores>().Where(x => x.ListaItens == null || !x.ListaItens.Any() || x.ListaItens.Any(p => p.Objeto == Constantes.NaoSelecionar)).ToList());
if (mostrarMensagem)
{
if (camposNaoPreenchidos.Count == 1)
{
await Estrutura.Mensagem("Falta preencher um campo obrigatório!").ConfigureAwait(false);
}
else if (camposNaoPreenchidos.Count > 1)
{
await Estrutura.Mensagem($"Existem {camposNaoPreenchidos.Count} campos obrigatórios que não foram preenchidos!").ConfigureAwait(false);
}
}
return(camposNaoPreenchidos);
}
public static T Deserializar <T>(string json) => string.IsNullOrEmpty(json) ? default : JsonConvert.DeserializeObject <T>(json, new JsonSerializerSettings
{
DateFormatString = Constantes.FormatoDataMesAnoHoraMinutoSegundo,
Error = async(sender, args) =>
{
var mensagem = $"{nameof(Constantes)}_{nameof(Deserializar)}<{typeof(T).NomeTipo()}>({json}): {args.ErrorContext.Error.Message}";
if (Debugger.IsAttached)
{
await Estrutura.Mensagem(mensagem).ConfigureAwait(false);
}
args.ErrorContext.Handled = true;
await Estrutura.Mensagem($"{nameof(Simplificadores)}_{nameof(Deserializar)}<{typeof(T).Name}>({json}): {mensagem}\n\n{args}").ConfigureAwait(false);
}
});
public static async Task <Tuple <bool, Usuario> > ConectarAsync(string usuario, string senha, ParametrosConfiguracao parametrosConfiguracao = null)
{
var resposta = new Tuple <bool, Usuario>(false, default);
//essencial para não gerar NullException
parametrosConfiguracao ??= new ParametrosConfiguracao();
if (string.IsNullOrEmpty(usuario) && string.IsNullOrEmpty(senha))
{
await Estrutura.Mensagem("Por favor digite o Usuário e a Senha!").ConfigureAwait(false);
}
else if (string.IsNullOrEmpty(usuario))
{
await Estrutura.Mensagem("Por favor digite o Usuário!").ConfigureAwait(false);
}
else if (string.IsNullOrEmpty(senha))
{
await Estrutura.Mensagem("Por favor digite a Senha!").ConfigureAwait(false);
}
else if (parametrosConfiguracao.TokenCancelamento.IsCancellationRequested && parametrosConfiguracao.ListaMostrarMensagensErro.Contains(Enumeradores.TipoMostrarMensagensErro.Gerenciador))
{
await Estrutura.Mensagem($"{nameof(Gerenciador)}_{nameof(ConectarAsync)} está com o parâmetro {nameof(usuario)} e o valor sendo ({usuario.ValorTratado()}) foi cancelado antes de começar.").ConfigureAwait(false);
}
else if (Connectivity.NetworkAccess != NetworkAccess.Internet)
{
await Estrutura.Mensagem(Constantes.TextoSemConexao).ConfigureAwait(false);
}
else
{
var(statusResultado, usuarioResultado, erro) = await App.Conexao.ConectarAsync(usuario, senha, parametrosConfiguracao).ConfigureAwait(false);
if (parametrosConfiguracao.ListaMostrarMensagensErro.Contains(Enumeradores.TipoMostrarMensagensErro.Gerenciador) && !string.IsNullOrEmpty(erro?.MensagemDetalhada) && erro.MensagemDetalhada != Erro.ValorMensagemPadrao)
{
await Estrutura.Mensagem(erro.MensagemDetalhada).ConfigureAwait(false);
}
resposta = new Tuple <bool, Usuario>(statusResultado.HttpStatusCodeSuccess(), usuarioResultado);
}
return(resposta);
}
public async Task <Tuple <HttpStatusCode, Usuario, Erro> > ConectarAsync(string usuario, string senha, ParametrosConfiguracao parametrosConfiguracao = null)
{
Tuple <HttpStatusCode, Usuario, Erro> retorno;
var estruturaJson = new
{
Login = usuario,
Senha = senha
};
var valoresJson = JsonConvert.SerializeObject(estruturaJson);
var contentJson = new StringContent(valoresJson, Encoding.UTF8, "application/json");
//essencial para não gerar NullException
parametrosConfiguracao ??= new ParametrosConfiguracao();
try
{
var objetoModelo = new
{
Status = 0,
Usuario = default(Usuario),
Mensagem = string.Empty
};
var respostaUsuario = await Cliente.PostAsync("usuario/validarusuarioappacesso", contentJson, parametrosConfiguracao.TokenCancelamento).ConfigureAwait(false);
var conteudoUsuario = await respostaUsuario.Content.ReadAsStringAsync().ConfigureAwait(false);
var respostaTratada = JsonConvert.DeserializeAnonymousType(conteudoUsuario, objetoModelo, Simplificadores.JsonSerializerSettingsPadrao);
var erroUsuario = JsonConvert.DeserializeAnonymousType(conteudoUsuario, objetoModelo, Simplificadores.JsonSerializerSettingsPadrao);
var respostaStatus = Enum.TryParse(typeof(HttpStatusCode), Convert.ToString(respostaTratada?.Status), true, out var status) ? (HttpStatusCode)status : respostaUsuario.StatusCode;
retorno = new Tuple <HttpStatusCode, Usuario, Erro>(respostaStatus, respostaTratada?.Usuario, respostaStatus.HttpStatusCodeSuccess() ? default : new Erro
{
Mensagem = erroUsuario?.Mensagem
});
}
catch (Exception ex)
{
await Estrutura.Mensagem($"{nameof(Conexao)}_{nameof(ConectarAsync)}({usuario}, {senha}): {ex.Message}\n\n{ex}").ConfigureAwait(false);
retorno = new Tuple <HttpStatusCode, Usuario, Erro>(default, default, new Erro(ex));
protected override void OnCreate(Bundle savedInstanceState)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(savedInstanceState);
AndroidEnvironment.UnhandledExceptionRaiser += async(sender, args) =>
{
var excecao = new Exception("AndroidEnvironmentOnUnhandledExceptionRaiser", args.Exception);
var mensagem = $"Mensagem: {excecao.Message}\n\nStackTrace: {excecao.StackTrace}\n\nObjeto: {(sender?.GetType().Name).ValorTratado()}";
await Estrutura.Mensagem($"{nameof(MainActivity)}_{nameof(OnCreate)}(): {mensagem}\n\n{excecao}").ConfigureAwait(false);
};
FFImageLoading.Forms.Platform.CachedImageRenderer.Init(true);
Plugin.CurrentActivity.CrossCurrentActivity.Current.Init(this, savedInstanceState);
ZXing.Mobile.MobileBarcodeScanner.Initialize(Application);
Platform.Init(this, savedInstanceState);
Xamarin.Forms.Forms.Init(this, savedInstanceState);
LoadApplication(new App());
}