private async void ChangeEmail()
        {
            var validationResult = EmailValidators.Validate(NewEmail);

            if (validationResult.IsValid)
            {
                string result = await App.Current.MainPage.DisplayPromptAsync("Enter your Password", "You are entering sudo mode.");

                string jSignInResponse = await Account.SignIn(Preferences.Get("ProfileEmail", "").ToString(), result);

                if (jSignInResponse.Contains("Error"))
                {
                    StandardMessagesDisplay.CommonToastMessage(jSignInResponse);
                }
                else if (jSignInResponse == "ConnectionError")
                {
                    StandardMessagesDisplay.NoConnectionToast();
                }
                else if (jSignInResponse == "ErrorTracked")
                {
                    StandardMessagesDisplay.ErrorTracked();
                }
                else
                {
                    JObject jo    = JObject.Parse(jSignInResponse);
                    var     Token = (string)jo.SelectToken("idToken");

                    var message = await Account.ChangeEmail(NewEmail.NewEmail, Token);

                    if (message == "OK")
                    {
                        StandardMessagesDisplay.EmailChanged(NewEmail.NewEmail);
                        await Xamarin.Essentials.SecureStorage.SetAsync("isLogged", "0");

                        string s1 = await Account.VerifyEmail(Token);

                        if (s1 == "OK")
                        {
                            StandardMessagesDisplay.EmailVerificationSend(NewEmail.NewEmail);
                        }
                    }
                    else
                    {
                        StandardMessagesDisplay.CanceledDisplayMessage();
                    }
                }
            }
            else
            {
                StandardMessagesDisplay.ValidationRulesViolation(validationResult.Errors[0].PropertyName, validationResult.Errors[0].ErrorMessage);
            }
        }
        private async void ChangePassword()
        {
            var result = PasswordValidator.Validate(NewPassword);

            if (result.IsValid)
            {
                string jSignInResponse = await Account.SignIn(Preferences.Get("ProfileEmail", "").ToString(), NewPassword.CurrentPassword);

                if (jSignInResponse.Contains("Error"))
                {
                    StandardMessagesDisplay.CommonToastMessage(jSignInResponse);
                }
                else if (jSignInResponse == "ConnectionError")
                {
                    StandardMessagesDisplay.NoConnectionToast();
                }
                else if (jSignInResponse == "ErrorTracked")
                {
                    StandardMessagesDisplay.ErrorTracked();
                }
                else
                {
                    JObject jo      = JObject.Parse(jSignInResponse);
                    var     Token   = (string)jo.SelectToken("idToken");
                    var     message = await Account.ChangeAccountPassword(Token, NewPassword.NewPassword);

                    if (message == "OK")
                    {
                        StandardMessagesDisplay.PasswordChanged();
                    }
                    else
                    {
                        StandardMessagesDisplay.CanceledDisplayMessage();
                    }
                }
            }
            else
            {
                StandardMessagesDisplay.ValidationRulesViolation(result.Errors[0].PropertyName, result.Errors[0].ErrorMessage);
            }
        }
Beispiel #3
0
        public async void SignIn(string userName, string userPassword)
        {
            if (Connectivity.NetworkAccess != NetworkAccess.Internet)
            {
                StandardMessagesDisplay.NoConnectionToast();
            }
            else
            {
                var jSignInResponse = await Account.SignIn(userName, userPassword);

                if (jSignInResponse.Contains("Error"))
                {
                    StandardMessagesDisplay.CommonToastMessage(jSignInResponse);
                }
                else if (jSignInResponse == "ConnectionError")
                {
                    StandardMessagesDisplay.NoConnectionToast();
                }
                else if (jSignInResponse == "ErrorTracked")
                {
                    StandardMessagesDisplay.ErrorTracked();
                }
                else
                {
                    try
                    {
                        var signInResponse = JsonConvert.DeserializeObject <JObject>(jSignInResponse);

                        if (signInResponse != null)
                        {
                            var localId = signInResponse?.GetValue("localId")?.ToString();
                            Preferences.Set("UserLocalId", localId);
                            Preferences.Set("ProfileEmail", signInResponse?.GetValue("email")?.ToString());

                            string accountInfoJson = await Account.AccountInfoLookup(signInResponse?.GetValue("idToken")?.ToString());

                            var accountInfo = JsonConvert.DeserializeObject <JObject>(accountInfoJson);

                            var claimsJson = accountInfo["users"][0]["customAttributes"]?.ToString();

                            var claims = JsonConvert.DeserializeObject <JObject>(claimsJson);

                            var role = claims.GetValue("Role")?.ToString();
                            Preferences.Set("UserRole", role);

                            if (RememberMe)
                            {
                                await Xamarin.Essentials.SecureStorage.SetAsync("isLogged", "1");
                            }

                            LoadProfile(Preferences.Get("UserLocalId", "").ToString());
                            await LoadCluster();
                            await LoadTeam();
                            await LoadVaccinePeriod();

                            GoToApp();
                        }
                    }
                    catch (Exception ex)
                    {
                        Crashes.TrackError(ex);
                        StandardMessagesDisplay.InputToast(ex.Message);
                    }
                }
            }
        }