simple list & gril view und parsing

1 files changed, 100 insertions, 8 deletions

diff --git a/modules/lists/lists.go b/modules/lists/lists.go
index 343ba62..519bb36 100644
--- a/modules/lists/lists.go
+++ b/modules/lists/lists.go
@@ -2,12 +2,16 @@ package lists
 
 import (
         "database/sql"
+        "errors"
         "fagott.pw/charakterin"
         "fagott.pw/grilist/frontend"
         "fagott.pw/grilist/grilist"
         "fagott.pw/grilist/modules/grils"
         "fmt"
+        "github.com/julienschmidt/httprouter"
         "log"
+        "net/http"
+        "strconv"
         "time"
 )
 
@@ -23,8 +27,15 @@ type List struct {
         Name        string
         Description string
         Owner       *charakterin.User
-        ForkOf      int
-        UpdatedAt   time.Time
+        ForkOf      *int
+        UpdatedAt   *time.Time
+        Grils       []*ListGril
+}
+
+// ListGril ist ein geranktes Gril
+type ListGril struct {
+        Gril  *grils.Gril
+        Order int
 }
 
 // Name gibt den Namen des Moduls zurück
@@ -46,6 +57,7 @@ func (m *Module) Init(g *grilist.Grilist) {
                 log.Fatal("lists: error with grils module")
         }
         m.grils = grilsModule
+        m.g.Router.GET("/list/:id", m.viewList)
 }
 
 // Interface gibt das Modul zurück
@@ -53,13 +65,40 @@ func (m *Module) Interface() interface{} {
         return m
 }
 
-// GetUserLists gibt die Listen eines Benutzers zurück.
-func (m *Module) GetUserLists(u *charakterin.User) []*List {
+func (m *Module) getListGrils(list *List) error {
+        rows, err := m.g.DB.Query(`SELECT gril_id, "order" FROM grilist.lists_grils WHERE list_id = $1`, list.ID)
+        if err != nil {
+                return err
+        }
+
+        defer rows.Close()
+        for rows.Next() {
+                var grilID int
+                lg := &ListGril{}
+
+                if err := rows.Scan(&grilID, &lg.Order); err != nil {
+                        log.Println("error scanning row in getListGrils:", err)
+                        continue
+                }
+
+                gril, err := m.grils.FromID(grilID)
+                if err != nil {
+                        log.Println("error getting listGril:", err)
+                        continue
+                }
+                lg.Gril = gril
+
+                list.Grils = append(list.Grils, lg)
+        }
+        return nil
+}
+
+func (m *Module) getLists(whereClause string, params ...interface{}) ([]*List, error) {
         var lists []*List
 
-        rows, err := m.g.DB.Query(`SELECT id, name, description, fork_of, updated_at FROM grilist.lists WHERE user_id = $1`, u.ID)
+        rows, err := m.g.DB.Query(fmt.Sprintf(`SELECT id, name, description, fork_of, updated_at FROM grilist.lists WHERE %s`, whereClause), params...)
         if err != nil {
-                return lists
+                return nil, err
         }
 
         defer rows.Close()
@@ -67,16 +106,43 @@ func (m *Module) GetUserLists(u *charakterin.User) []*List {
                 list := &List{}
 
                 if err := rows.Scan(&list.ID, &list.Name, &list.Description, &list.ForkOf, &list.UpdatedAt); err != nil {
-                        log.Println("error scanning row", err)
+                        log.Println("error scanning row in getLists:", err)
+                        continue
+                }
+
+                if err := m.getListGrils(list); err != nil {
+                        log.Println(err)
                         continue
                 }
 
                 lists = append(lists, list)
         }
 
+        return lists, nil
+}
+
+// GetUserLists gibt die Listen eines Benutzers zurück.
+func (m *Module) GetUserLists(u *charakterin.User) []*List {
+        lists, err := m.getLists(`user_id = $1`, u.ID)
+        if err != nil {
+                log.Println(err)
+        }
         return lists
 }
 
+// FromID sucht nach der Liste mit der gegebenen ID und gibt sie, falls sie existiert, zurück.
+func (m *Module) FromID(id int) (*List, error) {
+        lists, err := m.getLists(`id = $1`, id)
+        if err != nil {
+                return nil, err
+        }
+
+        if len(lists) == 0 {
+                return nil, errors.New("no list found")
+        }
+        return lists[0], nil
+}
+
 func mkCard(title, description string, actions ...frontend.Action) frontend.Card {
         card := frontend.Card{
                 Title:       title,
@@ -102,7 +168,7 @@ func rowsToCard(rows *sql.Rows) []frontend.Card {
                         continue
                 }
 
-                cards = append(cards, mkCard(title, description, frontend.Action{"anguckieren", fmt.Sprintf("/lists/%d", id)}))
+                cards = append(cards, mkCard(title, description, frontend.Action{"anguckieren", fmt.Sprintf("/list/%d", id)}))
         }
         return cards
 }
@@ -140,6 +206,32 @@ func (m *Module) ProvideDashboardData(user *charakterin.User) []grilist.Dashboar
         return categories
 }
 
+func (m *Module) viewList(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+        loggedIn := false
+        if user, _ := m.g.Charakterin.GetUserFromRequest(r); user != nil {
+                loggedIn = true
+        }
+        sid := p.ByName("id")
+
+        id, err := strconv.Atoi(sid)
+        if err != nil {
+                http.Redirect(w, r, "/", 302)
+                return
+        }
+
+        list, err := m.FromID(id)
+        if err != nil {
+                http.Redirect(w, r, "/", 302)
+                return
+        }
+
+        data := make(map[string]interface{})
+        data["loggedIn"] = loggedIn
+        data["list"] = list
+
+        m.g.Renderer.RenderPage("list", w, data)
+}
+
 // New erstellt eine neue Instanz des Modules
 func New() *Module {
         return &Module{}