1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
package lists
import (
"database/sql"
"fagott.pw/charakterin"
"fagott.pw/grilist/frontend"
"fagott.pw/grilist/grilist"
"fagott.pw/grilist/modules/grils"
"fmt"
"log"
"time"
)
// Module und so.
type Module struct {
g *grilist.Grilist
grils *grils.GrilsModule
}
// List ist eine Liste an DINGEN.
type List struct {
ID int
Name string
Description string
Owner *charakterin.User
ForkOf int
UpdatedAt time.Time
}
// Name gibt den Namen des Moduls zurück
func (m *Module) Name() string {
return "Lists"
}
// Init initialisiert das Modul
func (m *Module) Init(g *grilist.Grilist) {
m.g = g
gm, ok := g.Modules["Grils"]
if !ok {
log.Fatal("lists: grils module not found")
}
grilsModule, ok := gm.Interface().(*grils.GrilsModule)
if !ok {
log.Fatal("lists: error with grils module")
}
m.grils = grilsModule
}
// Interface gibt das Modul zurück
func (m *Module) Interface() interface{} {
return m
}
// GetUserLists gibt die Listen eines Benutzers zurück.
func (m *Module) GetUserLists(u *charakterin.User) []*List {
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)
if err != nil {
return lists
}
defer rows.Close()
for rows.Next() {
list := &List{}
if err := rows.Scan(&list.ID, &list.Name, &list.Description, &list.ForkOf, &list.UpdatedAt); err != nil {
log.Println("error scanning row", err)
continue
}
lists = append(lists, list)
}
return lists
}
func mkCard(title, description string, actions ...frontend.Action) frontend.Card {
card := frontend.Card{
Title: title,
Description: description,
Size: "medium",
}
for _, action := range actions {
card.Actions = append(card.Actions, action)
}
return card
}
func rowsToCard(rows *sql.Rows) []frontend.Card {
var cards []frontend.Card
for rows.Next() {
var id int
var title, description string
if err := rows.Scan(&id, &title, &description); err != nil {
log.Println("error scanning row", err)
continue
}
cards = append(cards, mkCard(title, description, frontend.Action{"anguckieren", fmt.Sprintf("/lists/%d", id)}))
}
return cards
}
// ProvideDashboardData gibt Daten für das Dashboard bezogen auf den Benutzer zurück
func (m *Module) ProvideDashboardData(user *charakterin.User) []grilist.DashboardCategory {
var categories []grilist.DashboardCategory
// Listen des Benutzers
rows, err := m.g.DB.Query(`SELECT id, name, description FROM grilist.lists WHERE user_id = $1`, user.ID)
if err != nil {
log.Println(err)
return []grilist.DashboardCategory{}
}
defer rows.Close()
categories = append(categories, grilist.DashboardCategory{
Title: "Meine Listen",
Cards: rowsToCard(rows),
})
// Neue Listen
rows, err = m.g.DB.Query(`SELECT id, name, description FROM grilist.lists ORDER BY id DESC LIMIT 5`)
if err != nil {
log.Println(err)
return categories
}
defer rows.Close()
categories = append(categories, grilist.DashboardCategory{
Title: "Neueste Listen",
Cards: rowsToCard(rows),
})
return categories
}
// New erstellt eine neue Instanz des Modules
func New() *Module {
return &Module{}
}
|
