Example #1
0
        private async Task UpdateLicniPodaci()
        {
            _apiSerivce.ChangeRoute(Routes.LicniPodaciRoute);
            byte[] uploadedPicBytes = null;

            if (UploadedPic != null)
            {
                using var ms = new MemoryStream();
                await UploadedPic.GetStream().CopyToAsync(ms);

                uploadedPicBytes = ms.ToArray();
            }

            var licniPodaci          = Pacijent.ZdravstvenaKnjizica.LicniPodaci;
            var licniPodaciUpsertDto = _mapper.Map <LicniPodaciUpsertDto>(licniPodaci);

            licniPodaciUpsertDto.ProfilePicture = uploadedPicBytes;

            var updateResult = await _apiSerivce.Update <LicniPodaciDto>(Pacijent.ZdravstvenaKnjizica.LicniPodaci.Id, licniPodaciUpsertDto);

            if (updateResult.Succeeded)
            {
                ProfilePicImageSource = ImageSource.FromStream(() => UploadedPic.GetStream());
                NotificationService.Instance.Toast(AppResources.Success);
            }
            else
            {
                NotificationService.Instance.Error(AppResources.Error);
            }
        }
 private async Task LoadPredefinedDataCounts()
 {
     _apiService = new APIService(Routes.DrzaveRoute);
     DrzavaCount = (await _apiService.Count())?.Data.First() ?? 0;
     _apiService.ChangeRoute(Routes.GradoviRoute);
     GradoviCount = (await _apiService.Count())?.Data.First() ?? 0;
     _apiService.ChangeRoute(Routes.ZdravstvenaStanjaRoute);
     ZdravstvenaStanjaCount = (await _apiService.Count())?.Data.First() ?? 0;
     _apiService.ChangeRoute(Routes.NaucneOblastiRoute);
     NaucneOblastiCount = (await _apiService.Count())?.Data.First() ?? 0;
     _apiService.ChangeRoute(Routes.RolesRoute);
     RolesCount = (await _apiService.Count())?.Data.First() ?? 0;
 }
Example #3
0
        private async void frmZahtevZaPregled_Load(object sender, EventArgs e)
        {
            if (ZahtevZaPregled != null)
            {
                _apiService.ChangeRoute(Routes.RecommendPregledTimeRoute);
                var result = await _apiService.GetAsSingle <DateTime>(
                    queryStringCollection : new Dictionary <string, string>
                {
                    {
                        "godiste",
                        ZahtevZaPregled?.Pacijent?.ZdravstvenaKnjizica?.LicniPodaci?.DatumRodjenja.Year.ToString()
                    }
                });

                if (result.Succeeded && result.HasData)
                {
                    RecommendedDateTime = result.Data;
                    timePregled.Value   = RecommendedDateTime;
                    datePregled.MinDate = DateTime.Now.AddDays(DateTime.Now.Hour < 9 ? 0 : 1);
                }
                else
                {
                    var currentHours = DateTime.Now.Hour;
                    var hoursToAdd   = currentHours > 17 ? 31 - currentHours : currentHours < 9 ? 9 - currentHours : 0;
                    timePregled.MinDate = DateTime.Now.AddHours(hoursToAdd);
                    datePregled.MinDate = DateTime.Now.AddDays(hoursToAdd > 9 ? 1 : 0);
                }

                txtZahtevZaPregled.Text = ZahtevZaPregled.Id.ToString();
                txtDoktor.Text          = ZahtevZaPregled.Doktor;
                txtPacijent.Text        = ZahtevZaPregled.Pacijent?.ZdravstvenaKnjizica?.LicniPodaci?.ImePrezime ?? "N/A";
            }
        }
        private async Task LoadCounts()
        {
            _apiService.ChangeRoute(Routes.PreglediRoute);
            var result = await _apiService.Count();

            if (!result.Succeeded && result.StatusCode == HttpStatusCode.Forbidden)
            {
                Close();
                Dispose();
                return;
            }
            PreglediCounter = result.Data.First();
            _apiService.ChangeRoute(Routes.ZahteviZaPregledRoute);
            ZakazivanjaPregledaCounter = (await _apiService.Count())?.Data.First() ?? 0;
            _apiService.ChangeRoute(Routes.ZahtevZaPosetuRoute);
            PoseteCounter = (await _apiService.Count())?.Data.First() ?? 0;
        }
        private async void btnAutoSchedulePosete_Click(object sender, System.EventArgs e)
        {
            _apiService.ChangeRoute(Routes.ZahteviZaPosetuAutoSchedulingRoute);
            var schedulingResult = await _apiService.Get <ZahtevZaPregledDtoEL>();

            if (schedulingResult.Succeeded)
            {
                dlgSuccess.ShowDialog();
            }
        }
        public async Task LoadPredefinedDataCount(string route)
        {
            switch (route)
            {
            case Routes.DrzaveRoute:
                _apiService           = new APIService(Routes.DrzaveRoute);
                DrzavaCount           = (await _apiService.Count())?.Data.First() ?? 0;
                lblDrzaveCounter.Text = DrzavaCount.ToString();
                break;

            case Routes.GradoviRoute:
                _apiService.ChangeRoute(Routes.GradoviRoute);
                GradoviCount           = (await _apiService.Count())?.Data.First() ?? 0;
                lblGradoviCounter.Text = GradoviCount.ToString();
                break;

            case Routes.ZdravstvenaStanjaRoute:
                _apiService.ChangeRoute(Routes.ZdravstvenaStanjaRoute);
                ZdravstvenaStanjaCount           = (await _apiService.Count())?.Data.First() ?? 0;
                lblZdravstvenaStanjaCounter.Text = ZdravstvenaStanjaCount.ToString();
                break;

            case Routes.NaucneOblastiRoute:
                _apiService.ChangeRoute(Routes.NaucneOblastiRoute);
                NaucneOblastiCount           = (await _apiService.Count())?.Data.First() ?? 0;
                lblNaucneOblastiCounter.Text = NaucneOblastiCount.ToString();

                break;

            case Routes.RolesRoute:
                _apiService.ChangeRoute(Routes.RolesRoute);
                RolesCount           = (await _apiService.Count())?.Data.First() ?? 0;
                lblRolesCounter.Text = RolesCount.ToString();
                break;

            default:
                return;
            }
        }
Example #7
0
        /// <summary>
        /// Authenticate user with username and password and get access token (store it in Auth.AccessToken)
        /// </summary>
        /// <returns>Returns boolean that indicates operation was succeeded or no</returns>
        public static async Task <bool> AuthenticateWithPassword(string username, string password)
        {
            try
            {
                var client = new OAuth2Client(new Uri(Settings.Default.IdpTokenEndpoint), Settings.Default.IdpClientId,
                                              Settings.Default.IdpClientSecret);
                var tokens = client.RequestAccessTokenUserName(username, password, string.Empty);
                if (tokens?.AccessToken == null)
                {
                    return(false);
                }

                AccessToken = new NetworkCredential(string.Empty, tokens.AccessToken).SecurePassword;

                var apiSerivce = new APIService(Routes.KorisniciRoute);

                var result = await apiSerivce.GetById <KorisnickiNalogDtoLL>(0);

                if (!result.Succeeded)
                {
                    AccessToken = null;
                    return(false);
                }
                KorisnickiNalog = result.Data;

                var topRole = KorisnickiNalog.Roles?.Min(x => x);
                Role = topRole.HasValue ? (RoleType)topRole : RoleType.Pacijent;

                if (Role == RoleType.Doktor)
                {
                    apiSerivce.ChangeRoute(Routes.DoktoriRoute);
                    var doktorResult = await apiSerivce.Get <DoktorDtoLL>(new DoktorResourceParameters
                                                                          { EqualUsername = KorisnickiNalog.Username });

                    if (doktorResult.Succeeded && doktorResult.HasData)
                    {
                        CurrentLoggedInDoktor = doktorResult.Data.First();
                    }
                }

                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
        private async void btnSaveNewPassword_Click(object sender, System.EventArgs e)
        {
            if (ValidateNewPasswordInputs())
            {
                _apiService.ChangeRoute($"{Routes.KorisniciRoute}/{Routes.ChangePasswordRoute}");
                var result = await _apiService.Post <KorisnickiNalogDtoLL>(new ChangePasswordDto
                {
                    CurrentPassword = txtCurrentPassword.Text,
                    NewPassword     = txtNewPassword.Text
                });

                if (result.Succeeded)
                {
                    dlgSuccess.ShowDialog();
                    tabSigurnost.Controls.ResetTextboxes();
                    tabUserProfile.SelectTab(tabLicniPodaci);
                }
            }
        }
Example #9
0
        private async void frmNewUputnica_Load(object sender, EventArgs e)
        {
            _apiService.ChangeRoute(Routes.DoktoriRoute);
            var result = await _apiService.Get <DoktorDtoEL>(new DoktorResourceParameters { EagerLoaded = true });

            if (!result.Succeeded || !result.HasData)
            {
                dlgError.ShowDialog("Greska pri ucitavanju podataka");
                return;
            }

            result.Data              = result.Data.Where(x => x.Id != Auth.CurrentLoggedInDoktor.Id).ToList();
            cmbDoktori.DataSource    = result.Data.Select(x => new ComboBoxItem($"{x.Radnik.Ime} {x.Radnik.Prezime}", x.Id)).ToList();
            cmbDoktori.ValueMember   = nameof(ComboBoxItem.Value);
            cmbDoktori.DisplayMember = nameof(ComboBoxItem.Text);
            cmbDoktori.SelectedValue = Uputnica != null
                ? Uputnica.UputioDoktorId == Auth.CurrentLoggedInDoktor.Id ? Uputnica.UpucenKodDoktoraId :
                                       Uputnica.UputioDoktorId
                : 0;
        }
        private async void btnSave_Click(object sender, EventArgs e)
        {
            if (ValidateInputs())
            {
                _apiService.ChangeRoute(Routes.LekarskoUverenjeRoute);
                var upsertDto = new LekarskoUverenjeUpsertDto
                {
                    OpisStanja          = txtOpisStanja.Text,
                    PregledId           = Pregled.Id,
                    ZdravstvenoStanjeId = (int)cmbZdravstvenoStanje.SelectedValue
                };

                var result = await _apiService.Post <LekarskoUverenjeDtoLL>(upsertDto);

                if (result.Succeeded)
                {
                    dlgSuccess.ShowDialog();
                    Close();
                    await frmDoktorPreglediDisplay.InstanceWithData(true).ReloadData();

                    frmDoktorPreglediDisplay.InstanceWithData(true).ShowSuccess();
                }
            }
        }
        private async void btnSave_Click(object sender, EventArgs e)
        {
            if (ValidateInputs())
            {
                RoleType roleChecked = RoleType.Doktor;
                if (rbtnRadnikPrijem.Checked)
                {
                    roleChecked = RoleType.RadnikPrijem;
                }
                else if (rbtnAdministrator.Checked)
                {
                    roleChecked = RoleType.Administrator;
                }

                var korisnickiNalogUpsertDto = new KorisnickiNalogUpsertDto
                {
                    Username        = txtUsername.Text,
                    Password        = txtPassword.Text,
                    ConfirmPassword = txtConfirmPassword.Text,
                    RoleType        = roleChecked.ToDescriptionString()
                };

                if (roleChecked == RoleType.Administrator)
                {
                    _apiService.ChangeRoute(Routes.KorisniciRoute);
                    var korisnickiNalogInsertResult =
                        await _apiService.Post <KorisnickiNalogDtoLL>(korisnickiNalogUpsertDto);

                    if (korisnickiNalogInsertResult.Succeeded)
                    {
                        dlgSuccess.ShowDialog();
                    }
                    return;
                }

                var licniPodaciUpsertDto = new LicniPodaciUpsertDto
                {
                    Ime          = txtIme.Text,
                    Prezime      = txtPrezime.Text,
                    Adresa       = txtAdresa.Text,
                    JMBG         = txtJmbg.Text,
                    BrojTelefona = txtBrojTelefona.Text,
                    EmailAddress = txtEmail.Text,
                    GradId       = int.Parse(cmbGradovi.SelectedValue.ToString()),
                    Pol          = cmbPolovi.SelectedIndex == 1 ? 'Z' : 'M'
                };

                bool SuccededInsert = true;
                if (rbtnDoktor.Checked)
                {
                    _apiService.ChangeRoute(Routes.DoktoriRoute);
                    var doktorUpsertDto = new DoktorUpsertDto
                    {
                        KorisnickiNalog        = korisnickiNalogUpsertDto,
                        LicniPodaci            = licniPodaciUpsertDto,
                        NaucnaOblastId         = int.Parse(cmbNaucneOblasti.SelectedValue.ToString()),
                        StacionarnoOdeljenjeId = int.Parse(cmbStacionarnaOdeljenja.SelectedValue.ToString())
                    };

                    var doktorInsertResult = await _apiService.Post <DoktorDtoLL>(doktorUpsertDto);

                    SuccededInsert = doktorInsertResult.Succeeded;
                }
                else
                {
                    var radnikUpsertDto = new RadnikPrijemUpsertDto
                    {
                        KorisnickiNalog        = korisnickiNalogUpsertDto,
                        LicniPodaci            = licniPodaciUpsertDto,
                        StacionarnoOdeljenjeId = int.Parse(cmbStacionarnaOdeljenja.SelectedValue.ToString())
                    };
                    if (rbtnMedTehnicar.Checked)
                    {
                        _apiService.ChangeRoute(Routes.MedicinskiTehnicariRoute);

                        var medTehnicarResult = await _apiService.Post <RadnikPrijemDtoLL>(radnikUpsertDto);

                        SuccededInsert = medTehnicarResult.Succeeded;
                    }
                    else if (rbtnRadnikPrijem.Checked)
                    {
                        _apiService.ChangeRoute(Routes.RadniciPrijemRoute);
                        var radnikPrijemResult = await _apiService.Post <RadnikPrijemDtoLL>(radnikUpsertDto);

                        SuccededInsert = radnikPrijemResult.Succeeded;
                    }
                }

                if (SuccededInsert)
                {
                    dlgSuccess.ShowDialog();
                }

                Close();
                frmStartMenuAdministrator.Instance.btnUsers.PerformClick();
                Dispose();
            }
        }