public async void Put()
        {
            if (VaccinePeriods != null)
            {
                var result = ValidationRules?.Validate(VaccinePeriods);
                if (result != null && result.IsValid)
                {
                    var jsonData = JsonConvert.SerializeObject(VaccinePeriods);
                    var data     = await DataService.Put(jsonData, $"VaccinePeriods/{VaccinePeriods.FId}");

                    if (data == "Submit")
                    {
                        StandardMessagesDisplay.EditDisplaymessage(VaccinePeriods.PeriodName);
                        var route = "..";
                        await Shell.Current.GoToAsync(route);
                    }
                    else
                    {
                        StandardMessagesDisplay.CanceledDisplayMessage();
                    }
                }
                else
                {
                    StandardMessagesDisplay.ValidationRulesViolation(result?.Errors[0].PropertyName, result?.Errors[0].ErrorMessage);
                }
            }
        }
        // Method
        private async void Put()
        {
            // Changing date to UTC time
            if (Vaccine != null)
            {
                var      time     = DateTime.Now;
                DateTime dateTime = new DateTime(Vaccine.VaccinePeriod.Year, Vaccine.VaccinePeriod.Month, Vaccine.VaccinePeriod.Day, time.Hour, time.Minute, time.Second, DateTimeKind.Utc);

                Vaccine.VaccinePeriod = dateTime;

                var jsonData = JsonConvert.SerializeObject(Vaccine);
                var data     = await DataService.Put(jsonData, $"Vaccine/{ChildId}/{Vaccine.FId}");

                if (data == "Submit")
                {
                    StandardMessagesDisplay.EditDisplaymessage(Vaccine.VaccineStatus);
                    var route = "..";
                    await Shell.Current.GoToAsync(route);
                }
                else
                {
                    StandardMessagesDisplay.CanceledDisplayMessage();
                }
            }
        }
Beispiel #3
0
        public async void Put()
        {
            if (Masjeed != null)
            {
                var result = ValidationRules?.Validate(Masjeed);
                if (result != null && result.IsValid)
                {
                    var jsonData = JsonConvert.SerializeObject(Masjeed);
                    var data     = await DataService.Put(jsonData, $"Masjeed/{Preferences.Get("TeamId", "")}/{Masjeed.FId}");

                    if (data == "Submit")
                    {
                        StandardMessagesDisplay.EditDisplaymessage(Masjeed.MasjeedName);
                        var route = "..";
                        await Shell.Current.GoToAsync(route);
                    }
                    else
                    {
                        StandardMessagesDisplay.CanceledDisplayMessage();
                    }
                }
                else
                {
                    StandardMessagesDisplay.ValidationRulesViolation(result?.Errors[0].PropertyName, result?.Errors[0].ErrorMessage);
                }
            }
        }
Beispiel #4
0
        private async void Put()
        {
            if (Child != null)
            {
                var result = ChildValidator?.Validate(Child);
                if (result != null && result.IsValid)
                {
                    var      time     = DateTime.Now;
                    DateTime dateTime = new DateTime(Child.DOB.Year, Child.DOB.Month, Child.DOB.Day, time.Hour, time.Minute, time.Second, DateTimeKind.Utc);

                    Child.DOB = dateTime;

                    var jsonData = JsonConvert.SerializeObject(Child);
                    var data     = await DataService.Put(jsonData, $"Child/{FamilyId}/{Child.FId}");

                    if (data == "Submit")
                    {
                        StandardMessagesDisplay.EditDisplaymessage(Child.FullName);
                        var route = "..";
                        await Shell.Current.GoToAsync(route);
                    }
                    else
                    {
                        StandardMessagesDisplay.CanceledDisplayMessage();
                    }
                }
                else
                {
                    StandardMessagesDisplay.ValidationRulesViolation(result?.Errors[0].PropertyName, result?.Errors[0].ErrorMessage);
                }
            }
        }
        public async void Delete()
        {
            if (CurrentVaccine?.FId != null)
            {
                var isDeleteAccepted = await StandardMessagesDisplay.DeleteDisplayMessage(CurrentVaccine.VaccineStatus);

                if (isDeleteAccepted)
                {
                    var data = await DataService.Delete($"Vaccine/{Child?.Id}/{CurrentVaccine.FId}");

                    if (data == "Deleted")
                    {
                        VaccineList?.Remove(CurrentVaccine);
                        CurrentVaccine = VaccineList.OrderBy(x => x.VaccinePeriod).LastOrDefault();
                    }
                    else
                    {
                        StandardMessagesDisplay.CanceledDisplayMessage();
                    }
                }
                else
                {
                    return;
                }
            }
            else
            {
                StandardMessagesDisplay.NoDataDisplayMessage();
            }
        }
        private async void Put()
        {
            if (Family != null)
            {
                var result = ValidationRules?.Validate(Family);
                if (result != null && result.IsValid)
                {
                    if (!StaticDataStore.FamilyNumbers.Contains(Family.HouseNo))
                    {
                        var jsonData = JsonConvert.SerializeObject(Family);
                        var data     = await DataService.Put(jsonData, $"Family/{Preferences.Get("TeamId", "")}/{Family.FId}");

                        if (data == "Submit")
                        {
                            StandardMessagesDisplay.EditDisplaymessage($"{Family.ParentName}'s Family ");
                            var route = "..";
                            await Shell.Current.GoToAsync(route);
                        }
                        else
                        {
                            StandardMessagesDisplay.CanceledDisplayMessage();
                        }
                    }
                    else
                    {
                        StandardMessagesDisplay.FamilyDuplicateValidator(Family.HouseNo);
                    }
                }
                else
                {
                    StandardMessagesDisplay.ValidationRulesViolation(result?.Errors[0].PropertyName, result?.Errors[0].ErrorMessage);
                }
            }
        }
Beispiel #7
0
        private async void Delete(object obj)
        {

            if (Masjeed.AreEmpty())
            {
                var isDeleteAccepted = await StandardMessagesDisplay.DeleteDisplayMessage(Masjeed.MasjeedName);
                if (isDeleteAccepted)
                {
                    Masjeed.IsActive = IsActive.MarkAsDelete;
                    var data22 = JsonConvert.SerializeObject(Masjeed);

                    var data = await DataService.Put(data22, $"Masjeed/{Preferences.Get("TeamId", "")}/{Masjeed.FId}");
                    if (data == "Submit")
                    {
                        _ = await DataService.Put((--StaticDataStore.TeamStats.TotalMasjeeds).ToString(), $"Team/{Preferences.Get("ClusterId", "")}/{Preferences.Get("TeamFId", "")}/TotalMasjeeds");
                        var route = $"//{nameof(MasjeedPage)}";
                        await Shell.Current.GoToAsync(route);
                    }
                    else
                    {
                        StandardMessagesDisplay.CanceledDisplayMessage();
                    }
                }
                else
                {
                    return;
                }

            }
            else
            {
                StandardMessagesDisplay.NoItemSelectedDisplayMessage();
            }
        }
        private async void SubmitIssue()
        {
            Feedback?.Labels.Add(AppVersionName);

            if (SuggestionRadioButton == false && ProblemRadioButton == true)
            {
                Feedback?.Labels.Add("Problem");
            }
            else
            {
                Feedback?.Labels.Add("Suggestion");
            }

            var role = await Xamarin.Essentials.SecureStorage.GetAsync("Role");

            if (role == "Mobilizer")
            {
                Feedback?.Labels.Add("mobilizer app");
            }
            else if (role == "Supervisor")
            {
                Feedback?.Labels.Add("supervisor app");
            }
            else if (role == "Parent")
            {
                Feedback?.Labels.Add("parent app");
            }
            else if (role == "Admin")
            {
                Feedback?.Labels.Add("Admin app");
            }

            if (AppPackageName == "com.codex.vaxineappbeta")
            {
                Feedback?.Labels.Add("beta-version");
            }

            // Serialize feedback
            var data   = JsonConvert.SerializeObject(Feedback);
            var result = await GithubRestService.SubmitIssue(data);

            if (result == "ConnectionError")
            {
                StandardMessagesDisplay.NoConnectionToast();
            }
            else if (result == "OK")
            {
                Feedback = new FeedbackModel();
                StandardMessagesDisplay.IssueSubmitToast();
            }
            else
            {
                StandardMessagesDisplay.CanceledDisplayMessage();
            }
        }
        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);
            }
        }