public async Task <IActionResult> Edit(int id, [Bind("Id,Naam,StraatEnNummer,Postcode,Woonplaats,Telefoonnummer,Email,Opmerkingen")] Klant klant)
        {
            if (id != klant.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(klant);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!KlantExists(klant.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(klant));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Categorie,Naam,Omschrijving,Prijs")] Gerecht gerecht)
        {
            if (id != gerecht.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(gerecht);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!GerechtExists(gerecht.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(gerecht));
        }
Example #3
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,BestellingId,GerechtId,Aantal,Opmerkingen")] BesteldGerecht besteldGerecht)
        {
            if (id != besteldGerecht.Id)
            {
                return(NotFound());
            }

            ControleerWijzigbaarheid(besteldGerecht);

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(besteldGerecht);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!BesteldGerechtExists(besteldGerecht.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                // Terug naar de bestelling waarvan dit bestelde gerecht deel uitmaakt.
                return(RedirectToAction(
                           nameof(BestellingController.Edit),
                           nameof(BestellingController).Replace("Controller", ""),
                           new { id = besteldGerecht.BestellingId }));
            }
            else
            {
                ViewData["BestellingId"] = new SelectList(
                    _context.Bestellingen,
                    "Id",
                    "Id",
                    besteldGerecht.BestellingId);
                ViewData["GerechtId"] = new SelectList(
                    FilterEnSorteerGerechten(besteldGerecht.BestellingId, besteldGerecht.GerechtId).Select(g => new
                {
                    Id = g.Id,
                    SamengesteldeNaam = $"{g.Categorie} - {g.Naam}"
                }),
                    "Id",
                    "SamengesteldeNaam",
                    besteldGerecht.GerechtId);

                // Terug naar de bestelling waarvan dit bestelde gerecht deel uitmaakt.
                return(View(besteldGerecht));
            }
        }
        public async Task <IActionResult> Edit(
            int id,
            [Bind("Id,Status,Betaald,KlantId,Tijdslot,Opmerkingen")] Bestelling bestelling,
            [Bind("actie")] string actie)
        {
            if (id != bestelling.Id)
            {
                return(NotFound());
            }

            // De vorige versie van de bestelling ophalen.
            Bestelling oudeBestelling = await _context.Bestellingen
                                        .AsNoTracking()
                                        .FirstOrDefaultAsync(b => b.Id == bestelling.Id);

            // Op de Edit.cshtml werden meerdere input's van het type 'submit' voorzien.
            // Elke submit heeft een eigen value die via deze switch omgezet wordt naar
            // een specifieke status op de bestelling.
            switch (actie)
            {
            case ACTIE_BESTELLEN:
                bestelling.Status = Bestelling.EnumStatus.Besteld;
                break;

            case ACTIE_AFLEVEREN:
                bestelling.Status = Bestelling.EnumStatus.Afgeleverd;
                break;

            case ACTIE_ANNULEREN:
                bestelling.Status = Bestelling.EnumStatus.Geannuleerd;
                break;

            case ACTIE_BEWAREN:
            // fallthrough naar 'default'.
            default:
                // Indien geen actie, geen status wijziging.
                // De 'oude' bestellingstatus wordt wel expliciet gezet omdat 'Status' mogelijk niet in de ge-POSTe form zit (cfr. disabled) OF omdat die gemanipuleerd zou kunnen zijn.
                bestelling.Status = oudeBestelling.Status;
                break;
            }

            // Het Bestelling-object dat aan deze action is 'gebind' is momenteel nog vrij leeg: er hangen geen child entiteiten onder.
            // Vandaar moeten deze dus uit de database opgehaald worden.
            bestelling.Klant = await(from k in _context.Klanten
                                     where k.Id == bestelling.KlantId
                                     select k).FirstAsync();
            bestelling.BesteldeGerechten = await(from bg in _context.BesteldeGerechten
                                                 .Include(bg => bg.Gerecht)
                                                 where bg.BestellingId == bestelling.Id
                                                 select bg).ToListAsync();

            // Controleren of eventuele wijzigingen en statusovergangen toegestaan zijn.
            await ControleerWijzigingen(oudeBestelling, bestelling);

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(bestelling);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!BestellingExists(bestelling.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Edit), new { id = bestelling.Id }));
            }
            else
            {
                ViewData["GeldigeWijzigingen"]      = oudeBestelling.BepaalGeldigeWijzigingen();      // Opgelet: de geldige wijzigingen mogen enkel bepaald worden op basis van de vorige versie.
                ViewData["GeldigeStatusovergangen"] = oudeBestelling.BepaalGeldigeStatusovergangen(); // Opgelet: de geldige statussen mogen enkel bepaald worden op basis van de vorige versie.
                ViewData["KlantId"] = new SelectList(_context.Klanten, "Id", "Email", bestelling.KlantId);
                ViewData["Prijs"]   = await BerekenTotalePrijsMetKorting(bestelling);

                bestelling.Status = oudeBestelling.Status; // Een eventuele aangevraagde statusovergang terug ongedaan maken.
                return(View(bestelling));
            }
        }