Example #1
0
        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);
            }
        });
Example #4
0
        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);
        }
Example #5
0
        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));
Example #6
0
        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());
        }