public async Task <IActionResult> Edit(int id, [Bind("Id,IdZahtjev,IdLokacija")] ZahtjevLokacija zahtjevLokacija)
        {
            if (id != zahtjevLokacija.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(zahtjevLokacija);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ZahtjevLokacijaExists(zahtjevLokacija.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdLokacija"] = new SelectList(_context.Lokacija, "Id", "Ulica", zahtjevLokacija.IdLokacija);
            ViewData["IdZahtjev"]  = new SelectList(_context.Zahtjev, "Id", "Opis", zahtjevLokacija.IdZahtjev);
            return(View(zahtjevLokacija));
        }
Exemple #2
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Tip,Marka,Boja,RegistarskaOznaka,Ekolosko,IdPrijevoznik")] Vozilo vozilo)
        {
            if (id != vozilo.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(vozilo);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!VoziloExists(vozilo.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdPrijevoznik"] = new SelectList(_context.Prijevoznik, "IdKorisnik", "IdKorisnik", vozilo.IdPrijevoznik);
            return(View(vozilo));
        }
        public async Task <IActionResult> Edit(int id, [Bind("IdKorisnik,ZahtijevaEko")] Narucitelj narucitelj)
        {
            if (id != narucitelj.IdKorisnik)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(narucitelj);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!NaruciteljExists(narucitelj.IdKorisnik))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdKorisnik"] = new SelectList(_context.Korisnik, "Id", "Prezime", narucitelj.IdKorisnik);
            return(View(narucitelj));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Razlog")] RazlogNaplate razlogNaplate)
        {
            if (id != razlogNaplate.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(razlogNaplate);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!RazlogNaplateExists(razlogNaplate.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(razlogNaplate));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,IdMjesto,IdVrstaLokacije,Ulica,KucniBroj")] Lokacija lokacija)
        {
            if (id != lokacija.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(lokacija);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!LokacijaExists(lokacija.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdMjesto"]        = new SelectList(_context.Mjesto, "Id", "Naziv", lokacija.IdMjesto);
            ViewData["IdVrstaLokacije"] = new SelectList(_context.VrstaLokacije, "Id", "Vrsta", lokacija.IdVrstaLokacije);
            return(View(lokacija));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,OcjenaPrijevoznika,OcjenaNarucitelja,OpisUslugePrijevoznika,OpisUslugeNarucitelja,IdPonudaPrijevoza")] Prijevoz prijevoz)
        {
            if (id != prijevoz.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(prijevoz);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!PrijevozExists(prijevoz.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdPonudaPrijevoza"] = new SelectList(_context.PonudaPrijevoza, "Id", "Id", prijevoz.IdPonudaPrijevoza);
            return(View(prijevoz));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id")] ProsireniPrijevozViewModel prosireniPrijevoz)
        {
            if (id != prosireniPrijevoz.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(prosireniPrijevoz);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ProsireniPrijevozExists(prosireniPrijevoz.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(prosireniPrijevoz));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,VrijemePocetka,VrijemeZavrsetka,CijenaNeizvrsenja,Sirina,Visina,Duiljina,Masa,Opis,IdStatusZahtjeva,IdNarucitelj")] Zahtjev zahtjev)
        {
            if (id != zahtjev.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(zahtjev);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ZahtjevExists(zahtjev.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdNarucitelj"]     = new SelectList(_context.Narucitelj, "IdKorisnik", "IdKorisnik", zahtjev.IdNarucitelj);
            ViewData["IdStatusZahtjeva"] = new SelectList(_context.StatusZahtjeva, "Id", "Status", zahtjev.IdStatusZahtjeva);
            return(View(zahtjev));
        }
Exemple #9
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Naziv,PostanskiBroj")] Mjesto mjesto)
        {
            if (id != mjesto.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(mjesto);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!MjestoExists(mjesto.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(mjesto));
        }
Exemple #10
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Cijena,RokIstekaPonude,RokOtkazaPonude,CijenaOtkaza,IdZahtjev,IdPrijevoznik,IdStatusPonude")] PonudaPrijevoza ponudaPrijevoza)
        {
            if (id != ponudaPrijevoza.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(ponudaPrijevoza);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!PonudaPrijevozaExists(ponudaPrijevoza.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdPrijevoznik"]  = new SelectList(_context.Prijevoznik, "IdKorisnik", "IdKorisnik", ponudaPrijevoza.IdPrijevoznik);
            ViewData["IdStatusPonude"] = new SelectList(_context.StatusPonude, "Id", "Status", ponudaPrijevoza.IdStatusPonude);
            ViewData["IdZahtjev"]      = new SelectList(_context.Zahtjev, "Id", "Opis", ponudaPrijevoza.IdZahtjev);
            return(View(ponudaPrijevoza));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Oib,Ime,Prezime,Lozinka,TelBroj,Email")] Korisnik korisnik)
        {
            if (id != korisnik.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(korisnik);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!KorisnikExists(korisnik.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(korisnik));
        }
Exemple #12
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,IdRazlog,IdVrstaNaplate,IdPrijevoz,RokIzvrsenjaNaplate")] Naplata naplata)
        {
            if (id != naplata.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(naplata);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = $"Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!NaplataExists(naplata.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["IdPrijevoz"]     = new SelectList(_context.Prijevoz, "Id", "Id", naplata.IdPrijevoz);
            ViewData["IdRazlog"]       = new SelectList(_context.RazlogNaplate, "Id", "Razlog", naplata.IdRazlog);
            ViewData["IdVrstaNaplate"] = new SelectList(_context.VrstaNaplate, "Id", "Vrsta", naplata.IdVrstaNaplate);
            return(View(naplata));
        }
Exemple #13
0
        public async Task <IActionResult> EditiranjeVozila(int id, [Bind("Id,Tip,Marka,Boja,RegistarskaOznaka,Ekolosko")] Vozilo vozilo)
        {
            if (id != vozilo.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    //PRIJAVLJENI KORISNIK!!
                    // trenutno: Ivana, Id = 1
                    int prijavljeniKorisnikId = 2;
                    var prijevoznik           = _context.Prijevoznik.Where(p => p.IdKorisnik == prijavljeniKorisnikId).FirstOrDefault();

                    var voz = _context.Vozilo.Where(v => v.Id == vozilo.Id).FirstOrDefault();

                    voz.Tip               = vozilo.Tip;
                    voz.Marka             = vozilo.Marka;
                    voz.Boja              = vozilo.Boja;
                    voz.RegistarskaOznaka = vozilo.RegistarskaOznaka;
                    voz.Ekolosko          = vozilo.Ekolosko;
                    voz.IdPrijevoznik     = prijevoznik.IdKorisnik;

                    _context.Update(voz);
                    await _context.SaveChangesAsync();

                    TempData[Constants.Message]       = "Ažuriranje uspješno obavljeno";
                    TempData[Constants.ErrorOccurred] = false;

                    string urlString = "Details/" + prijevoznik.IdKorisnik.ToString();
                    return(RedirectToAction(urlString));
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!VoziloExists(vozilo.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
            }
            return(View(vozilo));
        }