TODO Liste: der Controller

In den vorherigen Artikeln haben wir eine Datenbank für unsere TODO List-Webanwendung eingerichtet. Wir haben eine Model-, eine ViewModel- und eine Helper-Klasse sowie eine View-Klasse hinzugefügt, um die Liste visuell darzustellen. Jetzt ist es Zeit, den Klebstoff hinzuzufügen, der alles zusammenhält: Der Controller.

Der Controller

Die TODO List-Webanwendung, die wir gerade erstellen, dient nur einem Zweck: Es handelt sich um eine TODO List! Daher benötigen wir nur einen einzigen Controller, den HomeController. In einer größeren Anwendung würde es wahrscheinlich TodoController oder TodoListController heißen, aber wenn wir ihn den HomeController nennen, können wir vom Stammverzeichnis der Webanwendung aus auf die Indexansicht (die auch die einzige erforderliche Ansicht sein wird) zugreifen.

Unser Controller verfügt über mehrere Aktionen, mit denen wir der TODO-Liste neue Elemente hinzufügen sowie vorhandene Elemente bearbeiten oder löschen können. Für alle diese Aktionen ist eine eigene Methode erforderlich, für die möglicherweise eine Erklärung erforderlich ist. Daher gehe ich zunächst alle Methoden einzeln durch und erhalte am Ende die vollständige Auflistung des Controller-Codes.

Index():

public IActionResult Index()
{
    TodoListViewModel viewModel = new TodoListViewModel();        
    return View("Index", viewModel);
}

Hier passiert nicht viel. Da unsere TODO List-Anwendung nur eine einzige Ansicht hat, liefern wir diese hier aus. Da die Ansicht das TodoListViewModel verwendet, erstellen wir hier eine Instanz davon (die die TODO-Elemente lädt, wie im vorherigen Artikel beschrieben) und übergeben sie dann mit der View() -Methode an die Ansicht .

Edit():

public IActionResult Edit(int id)
{
    TodoListViewModel viewModel = new TodoListViewModel();
    viewModel.EditableItem = viewModel.TodoItems.FirstOrDefault(x => x.Id == id);
    return View("Index", viewModel);
}

Die Aktion Edit() funktioniert genau wie die Aktion Index(), mit Ausnahme der mittleren Zeile, in der wir die Eigenschaft EditableItem auf das vom Benutzer über ID angeforderte Parameter Element setzen. Wir verwenden dieselbe Ansicht (Index) erneut, die automatisch auf die Tatsache reagiert, dass wir jetzt ein vorhandenes TodoListItem übergeben.

Delete():

public IActionResult Delete(int id)
{
    using(var db = DbHelper.GetConnection())
    {
    TodoListItem item = db.Get<TodoListItem>(id);
    if(item != null)
        db.Delete(item);
    return RedirectToAction("Index");
    }
}

Die Delete() -Methode verwendet, ähnlich wie die Edit() -Methode, einen einzelnen Parameter namens id. Mit diesem Parameter können wir das angeforderte Element aus der Datenbank finden (mithilfe von der Get() -Methode von Dapper.Contrib) und wenn wir sie haben, können wir die Delete() -Methode aufrufen (erneut von Dapper.Contrib). Dies ist ein gutes Beispiel dafür, wie Dapper und Dapper.Contrib uns alles leichter macht - anstatt SQL zum Abrufen und Löschen einer Zeile schreiben zu müssen, verwenden wir einfach einfache .NET-Methoden.

CreateUpdate():

public IActionResult CreateUpdate(TodoListViewModel viewModel)
{
    if(ModelState.IsValid)
    {
    using(var db = DbHelper.GetConnection())
    {
        if(viewModel.EditableItem.Id <= 0)
        {
        viewModel.EditableItem.AddDate = DateTime.Now;
        db.Insert<TodoListItem>(viewModel.EditableItem);
        }
        else
        {
        TodoListItem dbItem = db.Get<TodoListItem>(viewModel.EditableItem.Id);
        var result = TryUpdateModelAsync<TodoListItem>(dbItem, "EditableItem");
        db.Update<TodoListItem>(dbItem);
        }
    }
    return RedirectToAction("Index");
    }
    else
    return View("Index", new TodoListViewModel());        
}

Die komplexeste Methode in unserem Controller ist die Methode CreateUpdate(). Da das FORMULAR, das wir in unserer Ansicht haben, sowohl zum Hinzufügen neuer Elemente als auch zum Bearbeiten vorhandener Elemente verwendet wird, muss die Methode, die die Anforderung verarbeitet, auch beide Situationen berücksichtigen.

Als Erstes überprüfen wir die ModelState.IsValid -Eigenschaft. Hier sehen wir, ob unser Modell gemäß der im vorherigen Artikel hinzugefügten Modellvalidierung validiert werden konnte oder nicht. Wenn es nicht gültig ist, rufen wir die View() -Methode auf und zeigen einfach die Indexansicht erneut an. Der ModelState wird jedoch eingeschlossen und in der Validierungszusammenfassung verwendet, die wir in unserer Ansicht anzeigen, um die bei der Validierung generierten Validierungsfehler anzuzeigen das Model.

Wenn das Modell gültig ist, sehen wir uns die Id-Eigenschaft des EditableItem an. Wenn sie nicht höher als Null ist, handelt es sich um ein neues Element. Wir weisen der AddDate -Eigenschaft einfach die aktuelle DateTime zu und rufen dann die Insert() -Methode auf, um unser neues Element in die Datenbank einzufügen.

Wenn die ID größer als Null ist, handelt es sich um einen vorhandenen Artikel. Wir holen das reale Objekt aus der Datenbank und rufen dann die TryUpdateModelAsync() -Methode auf. Dadurch wird das Objekt aus der Datenbank mit den Werten aktualisiert, die im auf dem Server veröffentlichten Modell gefunden wurden. In diesem Fall handelt es sich im Grunde nur um die Title -Eigenschaft. Sobald unser Modell aktualisiert wurde, schreiben wir die Änderungen zurück in die Datenbank, indem wir die Update() -Methode aufrufen.

Wenn dies alles erledigt ist, leiten wir einfach zu der Aktion Index um und setzen im Wesentlichen alles auf den vorherigen Stand zurück. Die vorgenommenen Änderungen werden automatisch übernommen, wenn die Aktion Index aufgerufen und das ViewModel geladen wird. Beachten Sie, dass wir während dieses Vorgangs keine Fehlerüberprüfung oder Ausnahmebehandlung durchführen, um das Beispiel so kompakt wie möglich zu halten. Sie sollten natürlich mindestens alle möglichen Ausnahmen in einer realen Anwendung behandeln.

ToggleIsDone:

public IActionResult ToggleIsDone(int id)
{
    using(var db = DbHelper.GetConnection())
    {
    TodoListItem item = db.Get<TodoListItem>(id);
    if(item != null)
    {
        item.IsDone = !item.IsDone;
        db.Update<TodoListItem>(item);
    }
    return RedirectToAction("Index");
    }
}

Wir aktivieren diese Aktion mit einem kleinen Stück JavaScript in unserer Ansicht. Mit der Methode Get() in der Datenbank wird einfach das TodoListItem abgerufen, das mit dem Parameter id angegeben wurde. Sobald wir den Gegenstand haben, ändern wir den IsDone in False, wenn er aktuell True ist und umgekehrt. Sobald wir dies getan haben, aktualisieren wir die entsprechende Zeile in der Datenbank mit der Update() -Methode.

Das war die letzte Methode in unserem Controller. Wie versprochen, ist hier die vollständige Codeliste:

using System;
using System.Linq;
using Microsoft.AspNetCore.Mvc;
using TodoList.Models;
using Dapper;
using Dapper.Contrib.Extensions;
using TodoList.ViewModels;
using TodoList.Helpers;

namespace TodoList.Controllers
{
    public class HomeController : Controller
    {
    public IActionResult Index()
    {
        TodoListViewModel viewModel = new TodoListViewModel();        
        return View("Index", viewModel);
    }

    public IActionResult Edit(int id)
    {
        TodoListViewModel viewModel = new TodoListViewModel();
        viewModel.EditableItem = viewModel.TodoItems.FirstOrDefault(x => x.Id == id);
        return View("Index", viewModel);
    }

    public IActionResult Delete(int id)
    {
        using(var db = DbHelper.GetConnection())
        {
        TodoListItem item = db.Get<TodoListItem>(id);
        if(item != null)
            db.Delete(item);
        return RedirectToAction("Index");
        }
    }

    public IActionResult CreateUpdate(TodoListViewModel viewModel)
    {
        if(ModelState.IsValid)
        {
        using(var db = DbHelper.GetConnection())
        {
            if(viewModel.EditableItem.Id <= 0)
            {
            viewModel.EditableItem.AddDate = DateTime.Now;
            db.Insert<TodoListItem>(viewModel.EditableItem);
            }
            else
            {
            TodoListItem dbItem = db.Get<TodoListItem>(viewModel.EditableItem.Id);
            TryUpdateModelAsync<TodoListItem>(dbItem, "EditableItem");
            db.Update<TodoListItem>(dbItem);
            }
        }
        return RedirectToAction("Index");
        }
        else
        return View("Index", new TodoListViewModel());        
    }

    public IActionResult ToggleIsDone(int id)
    {
        using(var db = DbHelper.GetConnection())
        {
        TodoListItem item = db.Get<TodoListItem>(id);
        if(item != null)
        {
            item.IsDone = !item.IsDone;
            db.Update<TodoListItem>(item);
        }
        return RedirectToAction("Index");
        }
    }
    }
}

Zusammenfassung

Herzlichen Glückwunsch, Sie haben gerade Ihre eigene datenbankgesteuerte TODO List-Webanwendung erstellt! Fügen Sie nun einige Elemente hinzu, klicken Sie auf den Titel, um das Element zu bearbeiten, aktivieren Sie das Kontrollkästchen, um die IsDone-Eigenschaft umzuschalten, oder klicken Sie auf die Schaltfläche Löschen, um ein Element zu entfernen. Alle Änderungen werden in der Datenbank angezeigt und beim nächsten Laden der Seite sichtbar - großartig!