Пример #1
0
        private async void dgvRezervacije_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            var id = dgvRezervacije.SelectedRows[0].Cells[0].Value;

            Model.Rezervacije rez = await _rezervacije.GetById <Model.Rezervacije>(int.Parse(id.ToString()));

            var termin = await _termini.GetById <Model.TerminiPutovanja>(rez.TerminPutovanjaId);


            DialogResult dialogResult = MessageBox.Show("Da li želite otkazati rezervaciju?", "Otkazivanje", MessageBoxButtons.YesNo);

            if (dialogResult == DialogResult.Yes)
            {
                if ((termin.DatumPolaska - DateTime.Now).TotalDays > 3)
                {
                    await _rezervacije.Delete <Model.Rezervacije>(id);

                    MessageBox.Show("Rezervacija otkazana.");
                }
                else
                {
                    MessageBox.Show("Nije moguće otkazati.");
                }
            }
        }
Пример #2
0
        public RezervacijeDetaljiPage()
        {
            InitializeComponent();

            var item = new Model.Rezervacije();

            viewModel      = new RezervacijeDetaljiViewModel(item);
            BindingContext = viewModel;
        }
        public async Task Save()
        {
            try
            {
                var result = await _klijentiService.Get <List <Model.Klijenti> >(new KlijentiSearchRequest()
                {
                    KorisnickoIme = APIService.Username
                });

                RezervacijeUpsertRequest request = new RezervacijeUpsertRequest()
                {
                    DatumKreiranja = DateTime.Now,
                    Status         = true,
                    Adresa         = Adresa,
                    GradId         = SelectedGrad.GradId,
                    KorisnikId     = null,
                    KlijentId      = result[0].KlijentId,
                    PopustId       = null,
                    Napomena       = Napomena
                };
                request.Artikli = new List <Model.RezervacijeArtikli>();
                request.Artikli.Add(new Model.RezervacijeArtikli()
                {
                    ArtikalId = Artikal.ArtikalId, Kolicina = int.Parse(Kolicina), Status = true
                });

                if (!string.IsNullOrWhiteSpace(Popust))
                {
                    List <Model.Popusti> list = await _popustiService.Get <List <Model.Popusti> >(null);

                    foreach (var item in list)
                    {
                        if (item.Kod.ToUpper().Equals(Popust.ToUpper()))
                        {
                            request.PopustId = item.PopustId;
                        }
                    }

                    if (request.PopustId == null)
                    {
                        await Application.Current.MainPage.DisplayAlert("Obavjest", $"Kod koji ste unijeli nije ispravan!", "Uredu");
                    }
                }
                Model.Rezervacije entity = null;
                entity = await _rezervacijeService.Insert <Model.Rezervacije>(request);

                if (entity != null)
                {
                    await Application.Current.MainPage.DisplayAlert("Obavjest", "Uspješno kreirana narudžba!", "Uredu");
                    await Init();
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
            }
        }
Пример #4
0
        public async Task OtkaziRezervaciju()
        {
            if (Rezervacija != null)
            {
                if (Rezervacija.Status)
                {
                    var totalDay = (int)(DateTime.Now.Date - Rezervacija.DatumKreiranja.Date).TotalDays;
                    if (totalDay > 1)
                    {
                        await Application.Current.MainPage.DisplayAlert("Greška", $"Rezervaciju nemoguće otkazati!", "OK");
                    }
                    else
                    {
                        Rezervacija.Status = false;

                        RezervacijeUpsertRequest request = new RezervacijeUpsertRequest()
                        {
                            KlijentId      = Rezervacija.KlijentId,
                            PopustId       = Rezervacija.PopustId,
                            GradId         = Rezervacija.GradId,
                            Adresa         = Rezervacija.Adresa,
                            KorisnikId     = Rezervacija.KorisnikId,
                            DatumKreiranja = Rezervacija.DatumKreiranja,
                            Napomena       = Rezervacija.Napomena,
                            Status         = Rezervacija.Status
                        };
                        request.Artikli = new List <Model.RezervacijeArtikli>();
                        foreach (var operma in Rezervacija.RezervacijeArtikli)
                        {
                            request.Artikli.Add(operma);
                        }

                        try
                        {
                            Model.Rezervacije entity = null;
                            entity = await _rezervacijeService.Update <Model.Rezervacije>(Rezervacija.RezervacijaId, request);

                            if (entity != null)
                            {
                                await Application.Current.MainPage.DisplayAlert("Obavjest", "Rezervacija uspješno otkazana!", "OK");
                                await Init();
                            }
                        }
                        catch
                        {
                            await Application.Current.MainPage.DisplayAlert("Greška", "Greška na serveru!", "Uredu");
                        }
                    }
                }
                else
                {
                    await Application.Current.MainPage.DisplayAlert("Greška", "Rezervacija već otkazana!", "Uredu");
                }
            }
        }
Пример #5
0
        public async Task OtkaziRezervaciju()
        {
            if (Item != null)
            {
                if (Item.Status)
                {
                    var totalDay = (int)(Item.DatumPreuzimanja.Date - DateTime.Now.Date).TotalDays;
                    if (totalDay <= 1)
                    {
                        await Application.Current.MainPage.DisplayAlert("Greška", $"Rezervaciju nemoguće otkazati dan prije datuma preuzimanja!", "Uredu");
                    }
                    else
                    {
                        Item.Status = false;

                        RezervacijeUpsertRequest request = new RezervacijeUpsertRequest()
                        {
                            KupacId                  = Item.KupacId,
                            VoziloId                 = Item.VoziloId,
                            OsiguranjeId             = Item.OsiguranjeId,
                            LokacijaPreuzimanjaId    = Item.LokacijaPreuzimanjaId,
                            LokacijaPovrataId        = Item.LokacijaPovrataId,
                            DatumPreuzimanja         = Item.DatumPreuzimanja,
                            DatumPovrata             = Item.DatumPovrata,
                            DatumKreiranjaRezervacij = Item.DatumKreiranjaRezervacij,
                            Napomena                 = Item.Napomena,
                            Status = Item.Status,
                        };
                        foreach (var operma in Item.DodatnaOprema)
                        {
                            request.Oprema.Add(operma.OpremaId);
                        }

                        try
                        {
                            Model.Rezervacije entity = null;
                            entity = await _rezervacijeServices.Update <Model.Rezervacije>(Item.RezervacijaId, request);

                            if (entity != null)
                            {
                                await Application.Current.MainPage.DisplayAlert("Obavjest", "Rezervacija otkazana!", "Uredu");
                                await Init();
                            }
                        }
                        catch {
                            await Application.Current.MainPage.DisplayAlert("Greška", "Greška na serveru!", "Uredu");
                        }
                    }
                }
                else
                {
                    await Application.Current.MainPage.DisplayAlert("Greška", "Rezervacija nije aktivna!", "Uredu");
                }
            }
        }
        private async void btnSacuvaj_Click(object sender, EventArgs e)
        {
            if (ValidateChildren() && dtm_Validating())
            {
                var opremaList = clbOprema.CheckedItems.Cast <Model.Oprema>().Select(x => x.OpremaId).ToList();

                var request = new RezervacijeUpsertRequest()
                {
                    KupacId                  = int.Parse(cbKupac.SelectedValue.ToString()),
                    VoziloId                 = int.Parse(cbVozilo.SelectedValue.ToString()),
                    OsiguranjeId             = int.Parse(cbOsiguranje.SelectedValue.ToString()),
                    LokacijaPovrataId        = int.Parse(cbLokacijaPovrata.SelectedValue.ToString()),
                    LokacijaPreuzimanjaId    = int.Parse(cbLokacijaPreuzimanja.SelectedValue.ToString()),
                    DatumKreiranjaRezervacij = DateTime.Now,
                    DatumPovrata             = dtpPovrata.Value.Date,
                    DatumPreuzimanja         = dtpPreuzimanja.Value.Date,
                    Napomena                 = txtNapomena.Text,
                    Status = chbStatus.Checked,
                    Oprema = opremaList,
                    Popust = numPopust.Value
                };


                Model.Rezervacije entity = null;
                if (_id.HasValue)
                {
                    entity = await _rezervacijeService.Update <Model.Rezervacije>(_id.Value, request);
                }
                else
                {
                    entity = await _rezervacijeService.Insert <Model.Rezervacije>(request);
                }

                if (entity != null)
                {
                    MessageBox.Show("Uspješno izvršeno");

                    var result = await _racuniService.Get <List <Model.Racuni> >(null);

                    foreach (var item in result)
                    {
                        if (item.RezervacijaId == entity.RezervacijaId && item.Status == true)
                        {
                            frmRacuniDetalji frm = new frmRacuniDetalji(item.RacunId);
                            frm.ShowDialog();
                            break;
                        }
                    }
                }
                this.Close();
            }
        }
Пример #7
0
        private async void btnSpremi_Click(object sender, EventArgs e)
        {
            if (ValidateChildren())
            {
                var korisnik = await _korisniciService.Get <List <Model.Korisnici> >(new KorisniciSearchRequest()
                {
                    KorisnickoIme = APIService.Username
                });

                var request = new RezervacijeUpsertRequest()
                {
                    Adresa = txtAdresa.Text, DatumKreiranja = DateTime.Now, Napomena = rtbNapomena.Text, Status = cbStatus.Checked, KorisnikId = korisnik.FirstOrDefault().KorisnikId, GradId = int.Parse(cbGrad.SelectedValue.ToString()), Placeno = true, IznosAvansnogPlacanje = 0
                };
                if (int.Parse(cbKlijent.SelectedValue.ToString()) != 0)
                {
                    request.KlijentId = int.Parse(cbKlijent.SelectedValue.ToString());
                }
                if (int.Parse(cbPopust.SelectedValue.ToString()) != 0)
                {
                    request.PopustId = int.Parse(cbPopust.SelectedValue.ToString());
                }

                request.Artikli = new List <Model.RezervacijeArtikli>();
                for (int i = 0; i < _listartikli.Count; i++)
                {
                    request.Artikli.Add(new Model.RezervacijeArtikli()
                    {
                        ArtikalId = _listartikli[i], Kolicina = _listkloicnia[i]
                    });
                }


                Model.Rezervacije entity = null;
                if (_id.HasValue)
                {
                    entity = await _rezervacijeService.Update <Model.Rezervacije>(_id.Value, request);
                }
                else
                {
                    entity = await _rezervacijeService.Insert <Model.Rezervacije>(request);
                }

                if (entity != null)
                {
                    MessageBox.Show("Uspješno izvršeno");
                }
                this.Close();
            }
        }
Пример #8
0
 public MojeRezervacijeDetaljiViewModel(Model.Rezervacije rezervacija = null)
 {
     Rezervacija = rezervacija;
     InitCommand = new Command(async() => await Init());
 }
 public DetaljiRezervacijePage(Model.Rezervacije rezervacija)
 {
     InitializeComponent();
     BindingContext = model = new DetaljiRezervacijeViewModel(rezervacija);
 }
        private async void btnSacuvaj_Click(object sender, EventArgs e)
        {
            if (clbSjedista.CheckedItems.Count > 0)
            {
                var rezervacija = await _rezervacije.GetById <Model.Rezervacije>(Id);

                var sjedista   = clbSjedista.CheckedItems.Cast <Model.Sjedista>();
                var projekcija = await _projekcije.GetById <Model.Projekcije>(cmbProjekcije.SelectedValue);

                var brojSjedista = sjedista.Count();
                RezervacijeUpsertRequest rezervacijaUpsert = new RezervacijeUpsertRequest()
                {
                    ProjekcijaId     = projekcija.ProjekcijaId,
                    BrojKarata       = brojSjedista,
                    Cijena           = brojSjedista * projekcija.Cijena,
                    DatumRezervacije = DateTime.Now,
                    Status           = chbAktivna.Checked
                };

                if (cmbGledaoci.SelectedValue != null)
                {
                    rezervacijaUpsert.GledalacId = (int)cmbGledaoci.SelectedValue;
                }

                rezervacijaUpsert.requestsUlaznice = new List <UlazniceUpsertRequest>();
                foreach (var item in sjedista)
                {
                    UlazniceUpsertRequest request = new UlazniceUpsertRequest()
                    {
                        RezervacijaId = Id,
                        ProjekcijaId  = int.Parse(cmbProjekcije.SelectedValue.ToString()),
                        SjedisteId    = item.SjedisteId,
                        Cijena        = projekcija.Cijena,
                        QRtekst       = $"Gledalac: {rezervacija.Gledalac?.Ime ?? "-Default-"} {rezervacija.Gledalac?.Prezime ?? "-Default-"} " +
                                        $"{rezervacija.Gledalac?.KorisnickoIme ?? "-Default-"} \n Projekcija: {rezervacija.Projekcija} \n",
                        Status = rezervacijaUpsert.Status// ako je rezervacija aktivna da bude i ulaznica i obrnuto
                    };
                    if (cmbGledaoci.SelectedIndex != 0)
                    {
                        var objGledalac = cmbGledaoci.SelectedValue;
                        rezervacijaUpsert.GledalacId = int.Parse(objGledalac?.ToString() ?? "0");
                    }

                    rezervacijaUpsert.requestsUlaznice.Add(request);
                }

                Model.Rezervacije result = null;
                if (Id.HasValue)
                {
                    result = await _rezervacije.Update <Model.Rezervacije>(Id, rezervacijaUpsert);
                }
                else
                {
                    result = await _rezervacije.Insert <Model.Rezervacije>(rezervacijaUpsert);
                }

                if (result != null)
                {
                    MessageBox.Show(Properties.Resources.UspjesnoPromijenjeno);
                }
            }
            else
            {
                MessageBox.Show("Niste odabrali nijedno sjedište.");
            }
        }
Пример #11
0
 public OcijeniFilmViewModel(Model.Rezervacije r)
 {
     rezervacija = r;
 }
        public async Task Uplati()
        {
            Model.Rezervacije entity = null;

            CreditCardModel          = new CreditCard();
            CreditCardModel.ExpMonth = Convert.ToInt64(Mjesec);
            CreditCardModel.ExpYear  = Convert.ToInt64(Godina);
            CreditCardModel.Number   = BrojKartice;
            CreditCardModel.Cvc      = Cvc;
            CancellationTokenSource tokenSource = new CancellationTokenSource();
            CancellationToken       token       = tokenSource.Token;

            try
            {
                UserDialogs.Instance.ShowLoading("Payment processing ...");
                await Task.Run(async() =>
                {
                    var Token = CreateTokenAsync();
                    Console.Write("Token :" + Token);
                    if (Token.ToString() != null)
                    {
                        IsTransectionSuccess = await MakePaymentAsync(Token.Result);
                    }
                    else
                    {
                        UserDialogs.Instance.Alert("Bad Card Credentials", null, "OK");
                    }
                });
            }
            catch (Exception ex)
            {
                UserDialogs.Instance.HideLoading();
                UserDialogs.Instance.Alert(ex.Message, null, "OK");
                Console.Write(ex.Message);
            }
            finally
            {
                try
                {
                    if (IsTransectionSuccess)
                    {
                        double iznos = double.Parse(Iznos);
                        request.IznosAvansnogPlacanje = (decimal)iznos;
                        request.Placeno = false;
                        if (iznos == ukupanIznos)
                        {
                            request.Placeno = true;
                        }

                        entity = await _rezervacijeServices.Insert <Model.Rezervacije>(request);

                        Console.Write($"Uspješno realizovana narudzba, uplaćeni avans: {ukupanIznos} KM!");
                        UserDialogs.Instance.HideLoading();
                    }
                    else
                    {
                        UserDialogs.Instance.HideLoading();
                        Console.Write("Payment Failure ");
                    }
                }
                catch (Exception) {
                    Console.Write("Transakcija nije uspjela!");
                }
            }
        }
 public DetaljiRezervacijeViewModel(Model.Rezervacije rezervacija = null)
 {
     r = rezervacija;
     UcitajPodatkeCommand     = new Command(async() => await UcitajPodatke());
     OtkaziRezervacijuCommand = new Command(async() => await OtkaziRezervaciju());
 }
Пример #14
0
 public SjedistaViewModel(Model.Rezervacije r)
 {
     InitCommand = new Command(async() => await Init());
     rezervacija = r;
 }
Пример #15
0
 public RezervacijeDetaljiViewModel(Model.Rezervacije item = null)
 {
     Title       = "Pregled rezervacije";
     Item        = item;
     InitCommand = new Command(async() => await Init());
 }
Пример #16
0
 public OcijeniFilmPage(Model.Rezervacije rezervacija)
 {
     InitializeComponent();
     r = rezervacija;
     BindingContext = model = new OcijeniFilmViewModel(rezervacija);
 }