Also missed rss.go

cmd/control/markdown.go

@@ -1,4 +1,4 @@
-package data
+package control
 
 import (
 	"bytes"

cmd/control/rss.go

@@ -0,0 +1,50 @@
+package control
+
+import (
+	"fmt"
+	"time"
+
+	"git.streifling.com/jason/rss"
+	"streifling.com/jason/cpolis/cmd/model"
+)
+
+func GetChannel(db *model.DB, title, link, desc string) (*rss.Channel, error) {
+	channel := &rss.Channel{
+		Title:       title,
+		Link:        link,
+		Description: desc,
+		Items:       make([]*rss.Item, 0),
+	}
+
+	articles, err := db.GetCertainArticles(true)
+	if err != nil {
+		return nil, fmt.Errorf("error fetching published articles: %v", err)
+	}
+
+	for _, article := range articles {
+		tags, err := db.GetArticleTags(article.ID)
+		if err != nil {
+			return nil, fmt.Errorf("error fetching tags for article %v: %v", article.Title, err)
+		}
+		tagNames := make([]string, 0)
+		for _, tag := range tags {
+			tagNames = append(tagNames, tag.Name)
+		}
+
+		user, err := db.GetUser(article.AuthorID)
+		if err != nil {
+			return nil, fmt.Errorf("error finding user %v: %v", article.AuthorID, err)
+		}
+
+		channel.Items = append(channel.Items, &rss.Item{
+			Title:       article.Title,
+			Author:      user.FirstName + user.LastName,
+			PubDate:     article.Created.Format(time.RFC1123Z),
+			Description: article.Desc,
+			Content:     &rss.Content{Value: article.Content},
+			Categories:  tagNames,
+		})
+	}
+
+	return channel, nil
+}

cmd/control/sessions.go

@@ -1,4 +1,4 @@
-package data
+package control
 
 import (
 	"crypto/rand"

cmd/data/articles.go

@@ -1,206 +0,0 @@
-package data
-
-import (
-	"encoding/gob"
-	"fmt"
-	"os"
-	"sync"
-	"time"
-
-	"github.com/google/uuid"
-)
-
-type Article struct {
-	Title    string
-	Author   string
-	Created  time.Time
-	Desc     string
-	Content  string
-	Tags     []string
-	UUID     uuid.UUID
-	AuthorID int64
-}
-
-// TODO: setCh
-type ArticleList struct {
-	addCh    chan *Article
-	delCh    chan uuid.UUID
-	getCh    chan []Article
-	retCh    chan *Article
-	articles []*Article
-	wg       sync.WaitGroup
-}
-
-// TODO: setCh
-type TagList struct {
-	addCh chan string
-	getCh chan []string
-	tags  []string
-	wg    sync.WaitGroup
-}
-
-func initArticleList() *ArticleList {
-	return &ArticleList{
-		addCh: make(chan *Article),
-		delCh: make(chan uuid.UUID),
-		getCh: make(chan []Article),
-		retCh: make(chan *Article),
-	}
-}
-
-func initTagList() *TagList {
-	return &TagList{
-		addCh: make(chan string),
-		getCh: make(chan []string),
-	}
-}
-
-func (al *ArticleList) start() {
-	al.wg.Done()
-	for {
-		select {
-		case article := <-al.addCh:
-			al.articles = append(al.articles, article)
-		case uuid := <-al.delCh:
-			for i, article := range al.articles {
-				if article.UUID == uuid {
-					al.articles = append(al.articles[:i], al.articles[i+1:]...)
-					al.retCh <- article
-				}
-			}
-		case al.getCh <- func() []Article {
-			var list []Article
-			for _, article := range al.articles {
-				list = append(list, *article)
-			}
-			return list
-		}():
-		}
-	}
-}
-
-func (tl *TagList) start() {
-	tl.wg.Done()
-	for {
-		select {
-		case tag := <-tl.addCh:
-			tl.tags = append(tl.tags, tag)
-		case tl.getCh <- tl.tags:
-		}
-	}
-}
-
-func NewArticleList() *ArticleList {
-	list := initArticleList()
-	list.articles = make([]*Article, 0)
-
-	list.wg.Add(1)
-	go list.start()
-	list.wg.Wait()
-
-	return list
-}
-
-func (al *ArticleList) Add(a *Article) {
-	al.addCh <- a
-}
-
-func (al *ArticleList) Release(uuid uuid.UUID) (*Article, bool) {
-	al.delCh <- uuid
-	article := <-al.retCh
-
-	if article == nil {
-		return nil, false
-	}
-	return article, true
-}
-
-func (al *ArticleList) Get() []Article {
-	return <-al.getCh
-}
-
-func (al *ArticleList) Save(filename string) error {
-	file, err := os.Create(filename)
-	if err != nil {
-		return fmt.Errorf("error creating key file: %v", err)
-	}
-	defer file.Close()
-
-	articles := al.Get()
-	if err = gob.NewEncoder(file).Encode(articles); err != nil {
-		return fmt.Errorf("error ecoding key: %v", err)
-	}
-
-	return nil
-}
-
-func LoadArticleList(filename string) (*ArticleList, error) {
-	file, err := os.Open(filename)
-	if err != nil {
-		return nil, fmt.Errorf("error opening key file: %v", err)
-	}
-
-	articleList := initArticleList()
-	if err = gob.NewDecoder(file).Decode(&articleList.articles); err != nil {
-		return nil, fmt.Errorf("error decoding key: %v", err)
-	}
-
-	articleList.wg.Add(1)
-	go articleList.start()
-	articleList.wg.Wait()
-
-	return articleList, nil
-}
-
-func NewTagList() *TagList {
-	list := initTagList()
-	list.tags = make([]string, 0)
-
-	list.wg.Add(1)
-	go list.start()
-	list.wg.Wait()
-
-	return list
-}
-
-func (tl *TagList) Add(tag string) {
-	tl.addCh <- tag
-}
-
-func (tl *TagList) Get() []string {
-	return <-tl.getCh
-}
-
-func (tl *TagList) Save(filename string) error {
-	file, err := os.Create(filename)
-	if err != nil {
-		return fmt.Errorf("error creating key file: %v", err)
-	}
-	defer file.Close()
-
-	tags := tl.Get()
-	if err = gob.NewEncoder(file).Encode(tags); err != nil {
-		return fmt.Errorf("error ecoding key: %v", err)
-	}
-
-	return nil
-}
-
-func LoadTagList(filename string) (*TagList, error) {
-	file, err := os.Open(filename)
-	if err != nil {
-		return nil, fmt.Errorf("error opening key file: %v", err)
-	}
-	defer file.Close()
-
-	tagList := initTagList()
-	if err = gob.NewDecoder(file).Decode(&tagList.tags); err != nil {
-		return nil, fmt.Errorf("error decoding key: %v", err)
-	}
-
-	tagList.wg.Add(1)
-	go tagList.start()
-	tagList.wg.Wait()
-
-	return tagList, nil
-}

cmd/data/db.go

@@ -1,173 +0,0 @@
-package data
-
-import (
-	"database/sql"
-	"fmt"
-	"log"
-
-	"github.com/go-sql-driver/mysql"
-	"golang.org/x/crypto/bcrypt"
-)
-
-type DB struct {
-	*sql.DB
-}
-
-func OpenDB(dbName string) (*DB, error) {
-	var err error
-	db := DB{DB: &sql.DB{}}
-
-	cfg := mysql.NewConfig()
-	cfg.DBName = dbName
-	cfg.User, cfg.Passwd, err = getCredentials()
-	if err != nil {
-		return nil, fmt.Errorf("error reading user credentials for DB: %v", err)
-	}
-
-	db.DB, err = sql.Open("mysql", cfg.FormatDSN())
-	if err != nil {
-		return nil, fmt.Errorf("error opening DB: %v", err)
-	}
-	if err = db.Ping(); err != nil {
-		return nil, fmt.Errorf("error pinging DB: %v", err)
-	}
-
-	return &db, nil
-}
-
-func (db *DB) AddUser(user *User, pass string) error {
-	hashedPass, err := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost)
-	if err != nil {
-		return fmt.Errorf("error creating password hash: %v", err)
-	}
-
-	query := `
-    INSERT INTO users
-        (username, password, first_name, last_name, role)
-    VALUES (?, ?, ?, ?, ?)
-    `
-	if _, err = db.Exec(query, user.UserName, string(hashedPass), user.FirstName, user.LastName, user.Role); err != nil {
-		return fmt.Errorf("error inserting user into DB: %v", err)
-	}
-
-	return nil
-}
-
-func (db *DB) GetID(userName string) (int64, error) {
-	var id int64
-
-	query := `
-    SELECT id
-    FROM users
-    WHERE username = ?
-    `
-	row := db.QueryRow(query, userName)
-	if err := row.Scan(&id); err != nil {
-		return 0, fmt.Errorf("user not in DB: %v", err)
-	}
-
-	return id, nil
-}
-
-func (db *DB) CheckPassword(id int64, pass string) error {
-	var queriedPass string
-
-	query := `
-    SELECT password
-    FROM users
-    WHERE id = ?
-    `
-	row := db.QueryRow(query, id)
-	if err := row.Scan(&queriedPass); err != nil {
-		return fmt.Errorf("error reading password from DB: %v", err)
-	}
-
-	if err := bcrypt.CompareHashAndPassword([]byte(queriedPass), []byte(pass)); err != nil {
-		return fmt.Errorf("incorrect password: %v", err)
-	}
-
-	return nil
-}
-
-func (db *DB) ChangePassword(id int64, oldPass, newPass string) error {
-	tx, err := db.Begin()
-	if err != nil {
-		return fmt.Errorf("error starting transaction: %v", err)
-	}
-
-	var queriedPass string
-	getQuery := `
-    SELECT password
-    FROM users
-    WHERE id = ?
-    `
-	row := tx.QueryRow(getQuery, id)
-	if err := row.Scan(&queriedPass); err != nil {
-		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
-		}
-		return fmt.Errorf("error reading password from DB: %v", err)
-	}
-
-	if err := bcrypt.CompareHashAndPassword([]byte(queriedPass), []byte(oldPass)); err != nil {
-		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
-		}
-		return fmt.Errorf("incorrect password: %v", err)
-	}
-
-	newHashedPass, err := bcrypt.GenerateFromPassword([]byte(newPass), bcrypt.DefaultCost)
-	if err != nil {
-		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
-		}
-		return fmt.Errorf("error creating password hash: %v", err)
-	}
-
-	setQuery := `
-    UPDATE users
-    SET password = ?
-    WHERE id = ?
-    `
-	if _, err = tx.Exec(setQuery, string(newHashedPass), id); err != nil {
-		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
-		}
-		return fmt.Errorf("error updating password in DB: %v", err)
-	}
-
-	if err = tx.Commit(); err != nil {
-		return fmt.Errorf("error committing transaction: %v", err)
-	}
-
-	return nil
-}
-
-func (db *DB) CountEntries() (int64, error) {
-	var count int64
-
-	query := `SELECT COUNT(*) FROM users`
-	row := db.QueryRow(query)
-	if err := row.Scan(&count); err != nil {
-		return 0, fmt.Errorf("error counting rows in user DB: %v", err)
-	}
-
-	return count, nil
-}
-
-// TODO: No need for ID field in general
-func (db *DB) GetUser(id int64) (*User, error) {
-	user := new(User)
-	query := `
-    SELECT id, username, first_name, last_name, role
-    FROM users
-    WHERE id = ?
-    `
-
-	row := db.QueryRow(query, id)
-	if err := row.Scan(&user.ID, &user.UserName, &user.FirstName, &user.LastName, &user.Role); err != nil {
-		return nil, fmt.Errorf("error reading user information: %v", err)
-	}
-
-	return user, nil
-}

cmd/data/rss.go

@@ -1,104 +0,0 @@
-package data
-
-import (
-	"encoding/gob"
-	"fmt"
-	"os"
-	"sync"
-
-	"git.streifling.com/jason/rss"
-)
-
-type Channel struct {
-	addCh   chan *rss.Item
-	setCh   chan rss.Channel
-	getCh   chan rss.Channel
-	channel rss.Channel
-	wg      sync.WaitGroup
-}
-
-func initChannel() *Channel {
-	return &Channel{
-		addCh: make(chan *rss.Item),
-		setCh: make(chan rss.Channel),
-		getCh: make(chan rss.Channel),
-		channel: rss.Channel{
-			Items: make([]*rss.Item, 0),
-		},
-	}
-}
-
-func (c *Channel) start() {
-	c.wg.Done()
-	for {
-		select {
-		case item := <-c.addCh:
-			c.channel.Items = append(c.channel.Items, item)
-		case c.getCh <- c.channel:
-		case c.channel = <-c.setCh:
-		}
-	}
-}
-
-func NewChannel(title, link, desc string) *Channel {
-	channel := initChannel()
-	channel.channel = rss.Channel{
-		Title:       title,
-		Link:        link,
-		Description: desc,
-	}
-
-	channel.wg.Add(1)
-	go channel.start()
-	channel.wg.Wait()
-
-	return channel
-}
-
-func (c *Channel) Get() rss.Channel {
-	return <-c.getCh
-}
-
-func (f *Channel) Set(channel rss.Channel) {
-	f.setCh <- channel
-}
-
-func LoadChannel(filename string) (*Channel, error) {
-	file, err := os.Open(filename)
-	if err != nil {
-		return nil, fmt.Errorf("error opening file %v: %v", filename, err)
-	}
-	defer file.Close()
-
-	tmpChannel := new(rss.Channel)
-	if err = gob.NewDecoder(file).Decode(tmpChannel); err != nil {
-		return nil, fmt.Errorf("error decoding channel from file %v: %v", filename, err)
-	}
-
-	channel := initChannel()
-	channel.wg.Add(1)
-	go channel.start()
-	channel.wg.Wait()
-	channel.Set(*tmpChannel)
-
-	return channel, nil
-}
-
-func (c *Channel) Save(filename string) error {
-	file, err := os.Create(filename)
-	if err != nil {
-		return fmt.Errorf("error creating file %v: %v", filename, err)
-	}
-	defer file.Close()
-
-	channel := c.Get()
-	if err = gob.NewEncoder(file).Encode(channel); err != nil {
-		return fmt.Errorf("error encoding file %v: %v", filename, err)
-	}
-
-	return nil
-}
-
-func (c *Channel) Add(i *rss.Item) {
-	c.addCh <- i
-}

cmd/data/user.go

@@ -1,16 +0,0 @@
-package data
-
-const (
-	Admin = iota
-	Editor
-	Writer
-)
-
-type User struct {
-	UserName         string
-	FirstName        string
-	LastName         string
-	RejectedArticles []*Article
-	ID               int64
-	Role             int
-}

cmd/main.go

@@ -6,12 +6,13 @@ import (
 	"net/http"
 	"os"
 
-	"streifling.com/jason/cpolis/cmd/data"
-	"streifling.com/jason/cpolis/cmd/ui"
+	"streifling.com/jason/cpolis/cmd/control"
+	"streifling.com/jason/cpolis/cmd/model"
+	"streifling.com/jason/cpolis/cmd/view"
 )
 
 func init() {
-	gob.Register(data.User{})
+	gob.Register(model.User{})
 }
 
 func main() {
@@ -21,59 +22,47 @@ func main() {
 		log.Fatalln(err)
 	}
 	defer logFile.Close()
-	log.SetOutput(logFile)
+	// log.SetOutput(logFile)
 
-	db, err := data.OpenDB("cpolis")
+	db, err := model.OpenDB("cpolis")
 	if err != nil {
 		log.Fatalln(err)
 	}
 	defer db.Close()
 
-	feed, err := data.LoadChannel("tmp/rss.gob")
+	key, err := control.LoadKey("tmp/key.gob")
 	if err != nil {
-		log.Println(err)
-		feed = data.NewChannel("Freimaurer Distrikt Niedersachsen und Sachsen-Anhalt",
-			"https://distrikt-ni-st.de",
-			"Freiheit, Gleichheit, Brüderlichkeit, Toleranz und Humanität")
-	}
-
-	key, err := data.LoadKey("tmp/key.gob")
-	if err != nil {
-		key, err = data.NewKey()
+		key, err = control.NewKey()
 		if err != nil {
 			log.Fatalln(err)
 		}
-		data.SaveKey(key, "tmp/key.gob")
-	}
-	store := data.NewCookieStore(key)
-
-	articleList, err := data.LoadArticleList("tmp/unpublished-articles.gob")
-	if err != nil {
-		articleList = data.NewArticleList()
-	}
-
-	tagList, err := data.LoadTagList("tmp/tags.gob")
-	if err != nil {
-		tagList = data.NewTagList()
+		control.SaveKey(key, "tmp/key.gob")
 	}
+	store := control.NewCookieStore(key)
 
 	mux := http.NewServeMux()
-	mux.Handle("/web/static/", http.StripPrefix("/web/static/", http.FileServer(http.Dir("web/static/"))))
-	mux.HandleFunc("/", ui.HomePage(db, store))
+	mux.Handle("/web/static/", http.StripPrefix("/web/static/",
+		http.FileServer(http.Dir("web/static/"))))
+	mux.HandleFunc("/", view.HomePage(db, store))
 
-	mux.HandleFunc("GET /create-tag/", ui.CreateTag)
-	mux.HandleFunc("GET /create-user/", ui.CreateUser)
-	mux.HandleFunc("GET /hub/", ui.ShowHub(store))
-	mux.HandleFunc("GET /rss/", ui.ShowRSS(feed))
-	mux.HandleFunc("GET /unpublished-articles/", ui.ShowUnpublishedArticles(articleList))
-	mux.HandleFunc("GET /write-article/", ui.WriteArticle(tagList))
+	mux.HandleFunc("GET /create-tag/", view.CreateTag)
+	mux.HandleFunc("GET /create-user/", view.CreateUser)
+	mux.HandleFunc("GET /hub/", view.ShowHub(store))
+	mux.HandleFunc("GET /rss/", view.ShowRSS(
+		db,
+		"Freimaurer Distrikt Niedersachsen und Sachsen-Anhalt",
+		"https://distrikt-ni-st.de",
+		"Freiheit, Gleichheit, Brüderlichkeit, Toleranz und Humanität",
+	))
+	mux.HandleFunc("GET /unpublished-articles/", view.ShowUnpublishedArticles(db))
+	mux.HandleFunc("GET /write-article/", view.WriteArticle(db))
 
-	mux.HandleFunc("POST /add-tag/", ui.AddTag(tagList, store))
-	mux.HandleFunc("POST /add-user/", ui.AddUser(db, store))
-	mux.HandleFunc("POST /finish-article/", ui.FinishArticle(articleList, store))
-	mux.HandleFunc("POST /login/", ui.Login(db, store))
-	mux.HandleFunc("POST /review-article/", ui.ReviewArticle(articleList, store))
-	mux.HandleFunc("POST /publish-article/", ui.PublishArticle(feed, articleList, store))
+	mux.HandleFunc("POST /add-tag/", view.AddTag(db, store))
+	mux.HandleFunc("POST /add-user/", view.AddUser(db, store))
+	mux.HandleFunc("POST /finish-article/", view.FinishArticle(db, store))
+	mux.HandleFunc("POST /login/", view.Login(db, store))
+	mux.HandleFunc("POST /review-article/", view.ReviewArticle(db, store))
+	mux.HandleFunc("POST /publish-article/", view.PublishArticle(db, store))
 
 	log.Fatalln(http.ListenAndServe(":8080", mux))
 }

cmd/model/db.go

@@ -0,0 +1,342 @@
+package model
+
+import (
+	"database/sql"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/go-sql-driver/mysql"
+	"golang.org/x/crypto/bcrypt"
+)
+
+type DB struct {
+	*sql.DB
+}
+
+func OpenDB(dbName string) (*DB, error) {
+	var err error
+	db := DB{DB: &sql.DB{}}
+
+	cfg := mysql.NewConfig()
+	cfg.DBName = dbName
+	cfg.User, cfg.Passwd, err = getCredentials()
+	if err != nil {
+		return nil, fmt.Errorf("error reading user credentials for DB: %v", err)
+	}
+
+	db.DB, err = sql.Open("mysql", cfg.FormatDSN())
+	if err != nil {
+		return nil, fmt.Errorf("error opening DB: %v", err)
+	}
+	if err = db.Ping(); err != nil {
+		return nil, fmt.Errorf("error pinging DB: %v", err)
+	}
+
+	return &db, nil
+}
+
+func (db *DB) UpdateAttribute(table string, id int64, attribute string, val interface{}) error {
+	query := fmt.Sprintf(`
+    UPDATE %s
+    SET %s = ?
+    WHERE id = ?
+    `, table, attribute)
+	if _, err := db.Exec(query, val, id); err != nil {
+		return fmt.Errorf("error updating article in DB: %v", err)
+	}
+	return nil
+}
+
+func (db *DB) AddUser(user *User, pass string) error {
+	hashedPass, err := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost)
+	if err != nil {
+		return fmt.Errorf("error creating password hash: %v", err)
+	}
+
+	query := `
+    INSERT INTO users
+        (username, password, first_name, last_name, role)
+    VALUES (?, ?, ?, ?, ?)
+    `
+	if _, err = db.Exec(query, user.UserName, string(hashedPass), user.FirstName, user.LastName, user.Role); err != nil {
+		return fmt.Errorf("error inserting user into DB: %v", err)
+	}
+
+	return nil
+}
+
+func (db *DB) GetID(userName string) (int64, error) {
+	var id int64
+
+	query := `
+    SELECT id
+    FROM users
+    WHERE username = ?
+    `
+	row := db.QueryRow(query, userName)
+	if err := row.Scan(&id); err != nil {
+		return 0, fmt.Errorf("user not in DB: %v", err)
+	}
+
+	return id, nil
+}
+
+func (db *DB) CheckPassword(id int64, pass string) error {
+	var queriedPass string
+
+	query := `
+    SELECT password
+    FROM users
+    WHERE id = ?
+    `
+	row := db.QueryRow(query, id)
+	if err := row.Scan(&queriedPass); err != nil {
+		return fmt.Errorf("error reading password from DB: %v", err)
+	}
+
+	if err := bcrypt.CompareHashAndPassword([]byte(queriedPass), []byte(pass)); err != nil {
+		return fmt.Errorf("incorrect password: %v", err)
+	}
+
+	return nil
+}
+
+func (db *DB) ChangePassword(id int64, oldPass, newPass string) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return fmt.Errorf("error starting transaction: %v", err)
+	}
+
+	var queriedPass string
+	getQuery := `
+    SELECT password
+    FROM users
+    WHERE id = ?
+    `
+	row := tx.QueryRow(getQuery, id)
+	if err := row.Scan(&queriedPass); err != nil {
+		if rollbackErr := tx.Rollback(); rollbackErr != nil {
+			log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
+		}
+		return fmt.Errorf("error reading password from DB: %v", err)
+	}
+
+	if err := bcrypt.CompareHashAndPassword([]byte(queriedPass), []byte(oldPass)); err != nil {
+		if rollbackErr := tx.Rollback(); rollbackErr != nil {
+			log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
+		}
+		return fmt.Errorf("incorrect password: %v", err)
+	}
+
+	newHashedPass, err := bcrypt.GenerateFromPassword([]byte(newPass), bcrypt.DefaultCost)
+	if err != nil {
+		if rollbackErr := tx.Rollback(); rollbackErr != nil {
+			log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
+		}
+		return fmt.Errorf("error creating password hash: %v", err)
+	}
+
+	setQuery := `
+    UPDATE users
+    SET password = ?
+    WHERE id = ?
+    `
+	if _, err = tx.Exec(setQuery, string(newHashedPass), id); err != nil {
+		if rollbackErr := tx.Rollback(); rollbackErr != nil {
+			log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
+		}
+		return fmt.Errorf("error updating password in DB: %v", err)
+	}
+
+	if err = tx.Commit(); err != nil {
+		return fmt.Errorf("error committing transaction: %v", err)
+	}
+
+	return nil
+}
+
+func (db *DB) CountEntries() (int64, error) {
+	var count int64
+
+	query := `SELECT COUNT(*) FROM users`
+	row := db.QueryRow(query)
+	if err := row.Scan(&count); err != nil {
+		return 0, fmt.Errorf("error counting rows in user DB: %v", err)
+	}
+
+	return count, nil
+}
+
+// TODO: No need for ID field in general
+func (db *DB) GetUser(id int64) (*User, error) {
+	user := new(User)
+	query := `
+    SELECT id, username, first_name, last_name, role
+    FROM users
+    WHERE id = ?
+    `
+
+	row := db.QueryRow(query, id)
+	if err := row.Scan(&user.ID, &user.UserName, &user.FirstName, &user.LastName, &user.Role); err != nil {
+		return nil, fmt.Errorf("error reading user information: %v", err)
+	}
+
+	return user, nil
+}
+
+func (db *DB) AddTag(tagName string) error {
+	query := "INSERT INTO tags (name) VALUES (?)"
+	if _, err := db.Exec(query, tagName); err != nil {
+		return fmt.Errorf("error inserting tag into DB: %v", err)
+	}
+	return nil
+}
+
+func (db *DB) GetTagList() ([]*Tag, error) {
+	query := "SELECT id, name FROM tags"
+	rows, err := db.Query(query)
+	if err != nil {
+		return nil, fmt.Errorf("error querying tags: %v", err)
+	}
+
+	tagList := make([]*Tag, 0)
+	for rows.Next() {
+		tag := new(Tag)
+		if err = rows.Scan(&tag.ID, &tag.Name); err != nil {
+			return nil, fmt.Errorf("error scanning tag row: %v", err)
+		}
+		tagList = append(tagList, tag)
+	}
+
+	return tagList, nil
+}
+
+func (db *DB) AddArticle(a *Article) (int64, error) {
+	query := `
+    INSERT INTO articles
+        (title, description, content, published, author_id)
+    VALUES
+        (?, ?, ?, ?, ?)
+    `
+
+	result, err := db.Exec(query, a.Title, a.Desc, a.Content, a.Published, a.AuthorID)
+	if err != nil {
+		return 0, fmt.Errorf("error inserting article into DB: %v", err)
+	}
+	id, err := result.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("error retrieving last ID: %v", err)
+	}
+
+	return id, nil
+}
+
+func (db *DB) GetArticle(id int64) (*Article, error) {
+	query := `
+    SELECT title, created, description, content, published, author_id
+    FROM articles
+    WHERE id = ?
+    `
+	row := db.QueryRow(query, id)
+
+	article := new(Article)
+	var created []byte
+	var err error
+
+	if err := row.Scan(&article.Title, &created, &article.Desc,
+		&article.Content, &article.Published, &article.AuthorID); err != nil {
+		return nil, fmt.Errorf("error scanning article row: %v", err)
+	}
+
+	article.ID = id
+	article.Created, err = time.Parse("2006-01-02 15:04:05", string(created))
+	if err != nil {
+		return nil, fmt.Errorf("error parsing created: %v", err)
+	}
+
+	return article, nil
+}
+
+func (db *DB) GetCertainArticles(published bool) ([]*Article, error) {
+	query := `
+    SELECT id, title, created, description, content, author_id
+    FROM articles
+    WHERE published = ?
+    `
+	rows, err := db.Query(query, published)
+	if err != nil {
+		return nil, fmt.Errorf("error querying articles: %v", err)
+	}
+
+	articleList := make([]*Article, 0)
+	for rows.Next() {
+		article := new(Article)
+		var created []byte
+
+		if err = rows.Scan(&article.ID, &article.Title, &created, &article.Desc,
+			&article.Content, &article.AuthorID); err != nil {
+			return nil, fmt.Errorf("error scanning article row: %v", err)
+		}
+
+		article.Published = false
+		article.Created, err = time.Parse("2006-01-02 15:04:05", string(created))
+		if err != nil {
+			return nil, fmt.Errorf("error parsing created: %v", err)
+		}
+
+		articleList = append(articleList, article)
+	}
+
+	return articleList, nil
+}
+
+func (db *DB) WriteArticleTags(articleID int64, tagIDs []int64) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return fmt.Errorf("error starting transaction: %v", err)
+	}
+
+	for _, tagID := range tagIDs {
+		query := `
+        INSERT INTO articles_tags (article_id, tag_id)
+        VALUES (?, ?)
+        `
+		if _, err := tx.Exec(query, articleID, tagID); err != nil {
+			if rollbackErr := tx.Rollback(); rollbackErr != nil {
+				log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
+			}
+			return fmt.Errorf("error inserting into articles_tags: %v", err)
+		}
+	}
+
+	if err = tx.Commit(); err != nil {
+		return fmt.Errorf("error committing transaction: %v", err)
+	}
+	return nil
+}
+
+func (db *DB) GetArticleTags(articleID int64) ([]*Tag, error) {
+	query := `
+    SELECT t.id, t.name
+    FROM articles a
+    INNER JOIN articles_tags at ON a.id = at.article_id
+    INNER JOIN tags t ON at.tag_id = t.id
+    WHERE a.id = ?
+    `
+	rows, err := db.Query(query, articleID)
+	if err != nil {
+		return nil, fmt.Errorf("error querying articles_tags: %v", err)
+	}
+
+	tags := make([]*Tag, 0)
+	for rows.Next() {
+		tag := new(Tag)
+		if err = rows.Scan(&tag.ID, &tag.Name); err != nil {
+			return nil, fmt.Errorf("error scanning rows: %v", err)
+		}
+		tags = append(tags, tag)
+	}
+
+	return tags, nil
+}

cmd/model/helpers.go

@@ -1,4 +1,4 @@
-package data
+package model
 
 import (
 	"bufio"

cmd/model/structs.go

@@ -0,0 +1,35 @@
+package model
+
+import (
+	"time"
+)
+
+const (
+	Admin = iota
+	Editor
+	Writer
+)
+
+type User struct {
+	UserName         string
+	FirstName        string
+	LastName         string
+	RejectedArticles []*Article
+	ID               int64
+	Role             int
+}
+
+type Tag struct {
+	Name string
+	ID   int64
+}
+
+type Article struct {
+	Title     string
+	Created   time.Time
+	Desc      string
+	Content   string
+	Published bool
+	ID        int64
+	AuthorID  int64
+}

cmd/ui/rss.go

@@ -1,28 +0,0 @@
-package ui
-
-import (
-	"html/template"
-	"log"
-	"net/http"
-
-	"git.streifling.com/jason/rss"
-	"streifling.com/jason/cpolis/cmd/data"
-)
-
-func ShowRSS(c *data.Channel) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		channel := c.Get()
-		feed := rss.NewFeed()
-		feed.Channels = append(feed.Channels, &channel)
-		rss, err := feed.ToXML()
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		files := []string{"web/templates/index.html", "web/templates/feed.rss"}
-		tmpl, err := template.ParseFiles(files...)
-		template.Must(tmpl, err).Execute(w, rss)
-	}
-}

cmd/view/admin.go

@@ -1,4 +1,4 @@
-package ui
+package view
 
 import (
 	"fmt"
@@ -7,15 +7,16 @@ import (
 	"net/http"
 	"strconv"
 
-	"streifling.com/jason/cpolis/cmd/data"
+	"streifling.com/jason/cpolis/cmd/control"
+	"streifling.com/jason/cpolis/cmd/model"
 )
 
 type AddUserData struct {
-	*data.User
+	*model.User
 	Msg string
 }
 
-func inputsEmpty(user *data.User, pass, pass2 string) bool {
+func inputsEmpty(user *model.User, pass, pass2 string) bool {
 	return len(user.UserName) == 0 ||
 		len(user.FirstName) == 0 ||
 		len(user.LastName) == 0 ||
@@ -23,7 +24,7 @@ func inputsEmpty(user *data.User, pass, pass2 string) bool {
 		len(pass2) == 0
 }
 
-func checkUserStrings(user *data.User) (string, int, bool) {
+func checkUserStrings(user *model.User) (string, int, bool) {
 	userLen := 15
 	nameLen := 50
 
@@ -43,7 +44,7 @@ func CreateUser(w http.ResponseWriter, r *http.Request) {
 	template.Must(tmpl, err).ExecuteTemplate(w, "page-content", nil)
 }
 
-func AddUser(db *data.DB, s *data.CookieStore) http.HandlerFunc {
+func AddUser(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		role, err := strconv.Atoi(r.PostFormValue("role"))
 		if err != nil {
@@ -53,7 +54,7 @@ func AddUser(db *data.DB, s *data.CookieStore) http.HandlerFunc {
 		}
 
 		htmlData := AddUserData{
-			User: &data.User{
+			User: &model.User{
 				UserName:  r.PostFormValue("username"),
 				FirstName: r.PostFormValue("first-name"),
 				LastName:  r.PostFormValue("last-name"),
@@ -99,9 +100,9 @@ func AddUser(db *data.DB, s *data.CookieStore) http.HandlerFunc {
 			return
 		}
 		if num == 0 {
-			if htmlData.Role != data.Admin {
+			if htmlData.Role != model.Admin {
 				htmlData.Msg = "Der erste Benutzer muss ein Administrator sein."
-				htmlData.Role = data.Admin
+				htmlData.Role = model.Admin
 				tmpl, err := template.ParseFiles("web/templates/add-user.html")
 				tmpl = template.Must(tmpl, err)
 				tmpl.ExecuteTemplate(w, "page-content", htmlData)

cmd/view/articles.go

@@ -1,17 +1,16 @@
-package ui
+package view
 
 import (
 	"html/template"
 	"log"
 	"net/http"
-	"time"
+	"strconv"
 
-	"git.streifling.com/jason/rss"
-	"github.com/google/uuid"
-	"streifling.com/jason/cpolis/cmd/data"
+	"streifling.com/jason/cpolis/cmd/control"
+	"streifling.com/jason/cpolis/cmd/model"
 )
 
-func ShowHub(s *data.CookieStore) http.HandlerFunc {
+func ShowHub(s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		session, err := s.Get(r, "cookie")
 		if err != nil {
@@ -25,33 +24,55 @@ func ShowHub(s *data.CookieStore) http.HandlerFunc {
 	}
 }
 
-func WriteArticle(tl *data.TagList) http.HandlerFunc {
+func WriteArticle(db *model.DB) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+		tags, err := db.GetTagList()
+		if err != nil {
+			log.Println(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
 		tmpl, err := template.ParseFiles("web/templates/editor.html")
-		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", tl.Get())
+		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", tags)
 	}
 }
 
-func FinishArticle(al *data.ArticleList, s *data.CookieStore) http.HandlerFunc {
+func FinishArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		article := new(data.Article)
+		article := new(model.Article)
 		var err error
 
-		article.Title, err = data.ConvertToPlain(r.PostFormValue("editor-title"))
+		article.Title, err = control.ConvertToPlain(r.PostFormValue("editor-title"))
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 
-		article.Desc, err = data.ConvertToPlain(r.PostFormValue("editor-desc"))
+		article.Desc, err = control.ConvertToPlain(r.PostFormValue("editor-desc"))
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 
-		article.Content, err = data.ConvertToHTML(r.PostFormValue("editor-text"))
+		article.Content, err = control.ConvertToHTML(r.PostFormValue("editor-text"))
+		if err != nil {
+			log.Println(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		session, err := s.Get(r, "cookie")
+		if err != nil {
+			tmpl, err := template.ParseFiles("web/templates/login.html")
+			msg := "Session nicht mehr gültig. Bitte erneut anmelden."
+			template.Must(tmpl, err).ExecuteTemplate(w, "page-content", msg)
+		}
+
+		article.AuthorID = session.Values["id"].(int64)
+		article.ID, err = db.AddArticle(article)
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -59,22 +80,21 @@ func FinishArticle(al *data.ArticleList, s *data.CookieStore) http.HandlerFunc {
 		}
 
 		r.ParseForm()
-		article.Tags = append(article.Tags, r.Form["tags"]...)
-
-		session, err := s.Get(r, "cookie")
+		tags := make([]int64, 0)
+		for _, tag := range r.Form["tags"] {
+			tagID, err := strconv.ParseInt(tag, 10, 64)
 			if err != nil {
-			tmpl, err := template.ParseFiles("web/templates/login.html")
-			msg := "Session nicht mehr gültig. Bitte erneut anmelden."
-			template.Must(tmpl, err).ExecuteTemplate(w, "page-content", msg)
+				log.Println(err)
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+			tags = append(tags, tagID)
+		}
+		if err = db.WriteArticleTags(article.ID, tags); err != nil {
+			log.Println(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
 		}
-
-		article.UUID = uuid.New()
-		article.Author = session.Values["name"].(string)
-		article.Created = time.Now()
-		article.AuthorID = session.Values["id"].(int64)
-
-		al.Add(article)
-		al.Save("tmp/unpublished-articles.gob")
 
 		tmpl, err := template.ParseFiles("web/templates/hub.html")
 		tmpl = template.Must(tmpl, err)
@@ -82,61 +102,57 @@ func FinishArticle(al *data.ArticleList, s *data.CookieStore) http.HandlerFunc {
 	}
 }
 
-func ShowUnpublishedArticles(al *data.ArticleList) http.HandlerFunc {
+func ShowUnpublishedArticles(db *model.DB) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+		articles, err := db.GetCertainArticles(false)
+		if err != nil {
+			log.Println(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
 		tmpl, err := template.ParseFiles("web/templates/unpublished-articles.html")
-		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", al.Get())
+		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", articles)
 	}
 }
 
-func ReviewArticle(al *data.ArticleList, s *data.CookieStore) http.HandlerFunc {
+func ReviewArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		uuid, err := uuid.Parse(r.PostFormValue("uuid"))
+		id, err := strconv.ParseInt(r.PostFormValue("id"), 10, 64)
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 
-		for _, article := range al.Get() {
-			if article.UUID == uuid {
+		article, err := db.GetArticle(id)
+		if err != nil {
 			tmpl, err := template.ParseFiles("web/templates/to-be-published.html")
 			template.Must(tmpl, err).ExecuteTemplate(w, "page-content", article)
 			return
 		}
-		}
 
-		session, err := s.Get(r, "cookie")
-		if err != nil {
-			tmpl, err := template.ParseFiles("web/templates/login.html")
-			msg := "Session nicht mehr gültig. Bitte erneut anmelden."
-			template.Must(tmpl, err).ExecuteTemplate(w, "page-content", msg)
-		}
+		// session, err := s.Get(r, "cookie")
+		// if err != nil {
+		// 	tmpl, err := template.ParseFiles("web/templates/login.html")
+		// 	msg := "Session nicht mehr gültig. Bitte erneut anmelden."
+		// 	template.Must(tmpl, err).ExecuteTemplate(w, "page-content", msg)
+		// }
 
-		tmpl, err := template.ParseFiles("web/templates/hub.html")
+		tmpl, err := template.ParseFiles("web/templates/to-be-published.html")
 		tmpl = template.Must(tmpl, err)
-		tmpl.ExecuteTemplate(w, "page-content", session.Values["role"])
+		tmpl.ExecuteTemplate(w, "page-content", article)
 	}
 }
 
-func PublishArticle(c *data.Channel, al *data.ArticleList, s *data.CookieStore) http.HandlerFunc {
+func PublishArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		uuid, err := uuid.Parse(r.PostFormValue("uuid"))
+		id, err := strconv.ParseInt(r.PostFormValue("id"), 10, 64)
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 
-		article, ok := al.Release(uuid)
-		if !ok {
-			// TODO: Warnung anzeigen
-			// msg = "Alle Felder müssen ausgefüllt werden."
-			// tmpl, err := template.ParseFiles("web/templates/add-user.html")
-			// template.Must(tmpl, err).ExecuteTemplate(w, "page-content", msg)
-			return
-		}
-
 		session, err := s.Get(r, "cookie")
 		if err != nil {
 			tmpl, err := template.ParseFiles("web/templates/login.html")
@@ -144,15 +160,7 @@ func PublishArticle(c *data.Channel, al *data.ArticleList, s *data.CookieStore)
 			template.Must(tmpl, err).ExecuteTemplate(w, "page-content", msg)
 		}
 
-		c.Add(&rss.Item{
-			Title:       article.Title,
-			Author:      session.Values["name"].(string),
-			PubDate:     article.Created.Format(time.RFC1123Z),
-			Description: article.Desc,
-			Content:     &rss.Content{Value: article.Content},
-			Categories:  article.Tags,
-		})
-		c.Save("tmp/rss.gob")
+		db.UpdateAttribute("articles", id, "published", true)
 
 		tmpl, err := template.ParseFiles("web/templates/hub.html")
 		tmpl = template.Must(tmpl, err)

cmd/view/editor.go

@@ -1,10 +1,11 @@
-package ui
+package view
 
 import (
 	"html/template"
 	"net/http"
 
-	"streifling.com/jason/cpolis/cmd/data"
+	"streifling.com/jason/cpolis/cmd/control"
+	"streifling.com/jason/cpolis/cmd/model"
 )
 
 func CreateTag(w http.ResponseWriter, r *http.Request) {
@@ -12,10 +13,9 @@ func CreateTag(w http.ResponseWriter, r *http.Request) {
 	template.Must(tmpl, err).ExecuteTemplate(w, "page-content", nil)
 }
 
-func AddTag(tl *data.TagList, s *data.CookieStore) http.HandlerFunc {
+func AddTag(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		tl.Add(r.PostFormValue("tag"))
-		tl.Save("tmp/tags.gob")
+		db.AddTag(r.PostFormValue("tag"))
 
 		session, err := s.Get(r, "cookie")
 		if err != nil {

cmd/view/rss.go

@@ -0,0 +1,71 @@
+package view
+
+import (
+	"html/template"
+	"log"
+	"net/http"
+	"time"
+
+	"git.streifling.com/jason/rss"
+	"streifling.com/jason/cpolis/cmd/model"
+)
+
+func ShowRSS(db *model.DB, title, link, desc string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		channel := &rss.Channel{
+			Title:       title,
+			Link:        link,
+			Description: desc,
+			Items:       make([]*rss.Item, 0),
+		}
+
+		articles, err := db.GetCertainArticles(true)
+		if err != nil {
+			log.Println(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		for _, article := range articles {
+			tags, err := db.GetArticleTags(article.ID)
+			if err != nil {
+				log.Println(err)
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+			tagNames := make([]string, 0)
+			for _, tag := range tags {
+				tagNames = append(tagNames, tag.Name)
+			}
+
+			user, err := db.GetUser(article.AuthorID)
+			if err != nil {
+				log.Println(err)
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+
+			channel.Items = append(channel.Items, &rss.Item{
+				Title:       article.Title,
+				Author:      user.FirstName + user.LastName,
+				PubDate:     article.Created.Format(time.RFC1123Z),
+				Description: article.Desc,
+				Content:     &rss.Content{Value: article.Content},
+				Categories:  tagNames,
+			})
+		}
+
+		feed := rss.NewFeed()
+		feed.Channels = append(feed.Channels, channel)
+		rss, err := feed.ToXML()
+		if err != nil {
+			log.Println(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		files := []string{"web/templates/index.html", "web/templates/feed.rss"}
+		tmpl, err := template.ParseFiles(files...)
+		template.Must(tmpl, err).Execute(w, rss)
+	}
+}

cmd/view/sessions.go

@@ -1,4 +1,4 @@
-package ui
+package view
 
 import (
 	"fmt"
@@ -6,10 +6,11 @@ import (
 	"log"
 	"net/http"
 
-	"streifling.com/jason/cpolis/cmd/data"
+	"streifling.com/jason/cpolis/cmd/control"
+	"streifling.com/jason/cpolis/cmd/model"
 )
 
-func saveSession(w http.ResponseWriter, r *http.Request, s *data.CookieStore, u *data.User) error {
+func saveSession(w http.ResponseWriter, r *http.Request, s *control.CookieStore, u *model.User) error {
 	session, err := s.Get(r, "cookie")
 	if err != nil {
 		return fmt.Errorf("error getting session: %v", err)
@@ -26,7 +27,7 @@ func saveSession(w http.ResponseWriter, r *http.Request, s *data.CookieStore, u
 	return nil
 }
 
-func HomePage(db *data.DB, s *data.CookieStore) http.HandlerFunc {
+func HomePage(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		numRows, err := db.CountEntries()
 		if err != nil {
@@ -53,7 +54,7 @@ func HomePage(db *data.DB, s *data.CookieStore) http.HandlerFunc {
 	}
 }
 
-func Login(db *data.DB, s *data.CookieStore) http.HandlerFunc {
+func Login(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		userName := r.PostFormValue("username")
 		password := r.PostFormValue("password")

go.mod

@@ -5,8 +5,6 @@ go 1.22.0
 require (
 	git.streifling.com/jason/rss v0.0.0-20240305164907-524bf9676188
 	github.com/go-sql-driver/mysql v1.7.1
-	github.com/google/uuid v1.6.0
-	github.com/gorilla/feeds v1.1.2
 	github.com/gorilla/sessions v1.2.2
 	github.com/microcosm-cc/bluemonday v1.0.26
 	github.com/yuin/goldmark v1.7.0

go.sum

@@ -1,9 +1,3 @@
-git.streifling.com/jason/rss v0.0.0-20240305152729-9d8cc6464565 h1:/eO9NTksh+9yLz3HiYNR7BJo/iMTxxW5/d9h8I6vR6E=
-git.streifling.com/jason/rss v0.0.0-20240305152729-9d8cc6464565/go.mod h1:gpZF0nZbQSstMpyHD9DTAvlQEG7v4pjO5c7aIMWM4Jg=
-git.streifling.com/jason/rss v0.0.0-20240305160544-c8551159fe32 h1:G25NZzsD73rOkGYgV2vPUDviB0JXk5qi+dXOwB6J56U=
-git.streifling.com/jason/rss v0.0.0-20240305160544-c8551159fe32/go.mod h1:gpZF0nZbQSstMpyHD9DTAvlQEG7v4pjO5c7aIMWM4Jg=
-git.streifling.com/jason/rss v0.0.0-20240305160829-6cd08bb65d2a h1:TWQ9gwe7eWjaLUrZ0CJSc+sUUOw3VoGHlR3F8mH6vqs=
-git.streifling.com/jason/rss v0.0.0-20240305160829-6cd08bb65d2a/go.mod h1:gpZF0nZbQSstMpyHD9DTAvlQEG7v4pjO5c7aIMWM4Jg=
 git.streifling.com/jason/rss v0.0.0-20240305164907-524bf9676188 h1:C8M/j3f+cl5Y7YfGpU/ynb/SC/4tTYMDsyGFt3rswM8=
 git.streifling.com/jason/rss v0.0.0-20240305164907-524bf9676188/go.mod h1:gpZF0nZbQSstMpyHD9DTAvlQEG7v4pjO5c7aIMWM4Jg=
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
@@ -12,24 +6,14 @@ github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrt
 github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
 github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
 github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
 github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
-github.com/gorilla/feeds v1.1.2 h1:pxzZ5PD3RJdhFH2FsJJ4x6PqMqbgFk1+Vez4XWBW8Iw=
-github.com/gorilla/feeds v1.1.2/go.mod h1:WMib8uJP3BbY+X8Szd1rA5Pzhdfh+HCCAYT2z7Fza6Y=
 github.com/gorilla/securecookie v1.1.2 h1:YCIWL56dvtr73r6715mJs5ZvhtnY73hBvEF8kXD8ePA=
 github.com/gorilla/securecookie v1.1.2/go.mod h1:NfCASbcHqRSY+3a8tlWJwsQap2VX5pwzwo4h3eOamfo=
 github.com/gorilla/sessions v1.2.2 h1:lqzMYz6bOfvn2WriPUjNByzeXIlVzURcPmgMczkmTjY=
 github.com/gorilla/sessions v1.2.2/go.mod h1:ePLdVu+jbEgHH+KWw8I1z2wqd0BAdAQh/8LRvBeoNcQ=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/microcosm-cc/bluemonday v1.0.26 h1:xbqSvqzQMeEHCqMi64VAs4d8uy6Mequs3rQ0k/Khz58=
 github.com/microcosm-cc/bluemonday v1.0.26/go.mod h1:JyzOCs9gkyQyjs+6h10UEVSe02CGwkhd72Xdqh78TWs=
-github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
-github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/yuin/goldmark v1.7.0 h1:EfOIvIMZIzHdB/R/zVrikYLPPwJlfMcNczJFMs1m6sA=
 github.com/yuin/goldmark v1.7.0/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
 golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=

web/templates/editor.html

@@ -5,8 +5,8 @@
     <textarea name="editor-desc" placeholder="Beschreibung"></textarea>
     <textarea name="editor-text" placeholder="Artikel"></textarea>
     {{range .}}
-    <input id="{{.}}" name="tags" type="checkbox" value="{{.}}" />
-    <label for="{{.}}">{{.}}</label>
+    <input id="{{.Name}}" name="tags" type="checkbox" value="{{.ID}}" />
+    <label for="{{.Name}}">{{.Name}}</label>
     {{end}}
     <input type="submit" value="Senden" hx-post="/finish-article/" hx-target="#page-content" />
 </form>

web/templates/to-be-published.html

@@ -1,9 +1,9 @@
 {{define "page-content"}}
 <form>
-    <input name="editor-title" type="text" value="{{.Title}}" />
-    <textarea name="editor-desc">{{.Desc}}</textarea>
-    <textarea name="editor-text">{{.Content}}</textarea>
-    <input name="uuid" type="hidden" value="{{.UUID}}" />
+    <h2>{{.Title}}</h2>
+    <p>{{.Desc}}</p>
+    <span>{{.Content}}</span>
+    <input name="id" type="hidden" value="{{.ID}}" />
     <input type="submit" value="Veröffentlichen" hx-post="/publish-article/" hx-target="#page-content" />
     <input type="submit" value="Ablehnen" hx-post="/reject-article/" hx-target="#page-content" />
 </form>

web/templates/unpublished-articles.html

@@ -1,8 +1,8 @@
 {{define "page-content"}}
 <form>
     {{range .}}
-    <input required id="{{.UUID}}" name="uuid" type="radio" value="{{.UUID}}" />
-    <label for="{{.UUID}}">{{.Title}}</label>
+    <input required id="{{.ID}}" name="id" type="radio" value="{{.ID}}" />
+    <label for="{{.ID}}">{{.Title}}</label>
     {{end}}
     <input type="submit" value="Auswählen" hx-post="/review-article/" hx-target="#page-content" />
 </form>