Also missed rss.go

cmd/control/rss.go

@@ -8,15 +8,15 @@ import (
 	"streifling.com/jason/cpolis/cmd/model"
 )
 
-func GetChannel(db *model.DB, title, link, description string) (*rss.Channel, error) {
+func GetChannel(db *model.DB, title, link, desc string) (*rss.Channel, error) {
 	channel := &rss.Channel{
 		Title:       title,
 		Link:        link,
-		Description: description,
+		Description: desc,
 		Items:       make([]*rss.Item, 0),
 	}
 
-	articles, err := db.GetCertainArticles(true, false)
+	articles, err := db.GetCertainArticles(true)
 	if err != nil {
 		return nil, fmt.Errorf("error fetching published articles: %v", err)
 	}
@@ -40,7 +40,7 @@ func GetChannel(db *model.DB, title, link, description string) (*rss.Channel, er
 			Title:       article.Title,
 			Author:      user.FirstName + user.LastName,
 			PubDate:     article.Created.Format(time.RFC1123Z),
-			Description: article.Description,
+			Description: article.Desc,
 			Content:     &rss.Content{Value: article.Content},
 			Categories:  tagNames,
 		})

cmd/main.go

@@ -47,10 +47,7 @@ func main() {
 
 	mux.HandleFunc("GET /create-tag/", view.CreateTag)
 	mux.HandleFunc("GET /create-user/", view.CreateUser)
-	mux.HandleFunc("GET /edit-user/", view.EditUser(db, store))
-	mux.HandleFunc("GET /hub/", view.ShowHub(db, store))
-	mux.HandleFunc("GET /logout/", view.Logout(store))
-	mux.HandleFunc("GET /rejected-articles/", view.ShowRejectedArticles(db, store))
+	mux.HandleFunc("GET /hub/", view.ShowHub(store))
 	mux.HandleFunc("GET /rss/", view.ShowRSS(
 		db,
 		"Freimaurer Distrikt Niedersachsen und Sachsen-Anhalt",
@@ -62,14 +59,10 @@ func main() {
 
 	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))
-	mux.HandleFunc("POST /reject-article/", view.RejectArticle(db, store))
-	mux.HandleFunc("POST /resubmit-article/", view.ResubmitArticle(db, store))
-	mux.HandleFunc("POST /review-rejected-article/", view.ReviewRejectedArticle(db, store))
-	mux.HandleFunc("POST /review-unpublished-article/", view.ReviewUnpublishedArticle(db, store))
-	mux.HandleFunc("POST /submit-article/", view.SubmitArticle(db, store))
-	mux.HandleFunc("POST /update-user/", view.UpdateUser(db, store))
 
 	log.Fatalln(http.ListenAndServe(":8080", mux))
 }

cmd/model/articles.go

@@ -1,97 +0,0 @@
-package model
-
-import (
-	"fmt"
-	"time"
-)
-
-type Article struct {
-	Title       string
-	Created     time.Time
-	Description string
-	Content     string
-	Published   bool
-	Rejected    bool
-	ID          int64
-	AuthorID    int64
-}
-
-func (db *DB) AddArticle(a *Article) (int64, error) {
-	query := `
-    INSERT INTO articles
-        (title, description, content, published, rejected, author_id)
-    VALUES (?, ?, ?, ?, ?, ?)
-    `
-
-	result, err := db.Exec(query, a.Title, a.Description, a.Content,
-		a.Published, a.Rejected, 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.Description,
-		&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, rejected bool) ([]*Article, error) {
-	query := `
-    SELECT id, title, created, description, content, author_id
-    FROM articles
-    WHERE published = ?
-    AND rejected = ?
-    `
-	rows, err := db.Query(query, published, rejected)
-	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.Description,
-			&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
-}

cmd/model/articles_tags.go

@@ -1,72 +0,0 @@
-package model
-
-import (
-	"fmt"
-	"log"
-	"math"
-	"math/rand/v2"
-	"time"
-)
-
-func (db *DB) WriteArticleTags(articleID int64, tagIDs []int64) error {
-	for i := 0; i < TxMaxRetries; i++ {
-		err := func() 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
-		}()
-		if err == nil {
-			return nil
-		}
-
-		log.Println(err)
-		waitTime := time.Duration(math.Pow(2, float64(i))) * time.Second
-		jitter := time.Duration(rand.IntN(1000)) * time.Millisecond
-		time.Sleep(waitTime + jitter)
-	}
-	return fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
-}
-
-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/db.go

@@ -1,73 +1,17 @@
 package model
 
 import (
-	"bufio"
 	"database/sql"
 	"fmt"
 	"log"
-	"math"
-	"math/rand/v2"
-	"os"
-	"strings"
-	"syscall"
 	"time"
 
 	"github.com/go-sql-driver/mysql"
-	"golang.org/x/term"
+	"golang.org/x/crypto/bcrypt"
 )
 
-var TxMaxRetries = 3
-
-type (
-	DB        struct{ *sql.DB }
-	Tx        struct{ *sql.Tx }
-	Attribute struct {
-		Value   interface{}
-		Table   string
-		AttName string
-		ID      int64
-	}
-)
-
-func getUsername() (string, error) {
-	user := os.Getenv("DB_USER")
-	if user == "" {
-		var err error
-		fmt.Printf("DB Benutzer: ")
-		user, err = bufio.NewReader(os.Stdin).ReadString('\n')
-		if err != nil {
-			return "", fmt.Errorf("error reading username: %v", err)
-		}
-	}
-	return strings.TrimSpace(user), nil
-}
-
-func getPassword() (string, error) {
-	pass := os.Getenv("DB_PASS")
-	if pass == "" {
-		fmt.Printf("DB Passwort: ")
-		bytePass, err := term.ReadPassword(int(syscall.Stdin))
-		if err != nil {
-			return "", fmt.Errorf("error reading password: %v", err)
-		}
-		fmt.Println()
-		pass = strings.TrimSpace(string(bytePass))
-	}
-	return pass, nil
-}
-
-func getCredentials() (string, string, error) {
-	user, err := getUsername()
-	if err != nil {
-		return "", "", fmt.Errorf("error getting username: %v", err)
-	}
-
-	pass, err := getPassword()
-	if err != nil {
-		return "", "", fmt.Errorf("error getting password: %v", err)
-	}
-
-	return user, pass, nil
+type DB struct {
+	*sql.DB
 }
 
 func OpenDB(dbName string) (*DB, error) {
@@ -92,49 +36,130 @@ func OpenDB(dbName string) (*DB, error) {
 	return &db, nil
 }
 
-func (db *DB) UpdateAttributes(a ...*Attribute) error {
-	for i := 0; i < TxMaxRetries; i++ {
-		err := func() error {
-			tx, err := db.Begin()
-			if err != nil {
-				return fmt.Errorf("error starting transaction: %v", err)
-			}
-
-			for _, attribute := range a {
-				query := fmt.Sprintf(`
-                    UPDATE %s
-                    SET %s = ?
-                    WHERE id = ?
-                    `, attribute.Table, attribute.AttName)
-				if _, err := tx.Exec(query, attribute.Value, attribute.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 %v in DB: %v", attribute.AttName, err)
-				}
-			}
-
-			if err = tx.Commit(); err != nil {
-				return fmt.Errorf("error committing transaction: %v", err)
-			}
-			return nil
-		}()
-		if err == nil {
-			return nil
-		}
-
-		log.Println(err)
-		waitTime := time.Duration(math.Pow(2, float64(i))) * time.Second
-		jitter := time.Duration(rand.IntN(1000)) * time.Millisecond
-		time.Sleep(waitTime + jitter)
+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 fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
+	return nil
 }
 
-func (db *DB) CountEntries(table string) (int64, error) {
+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 := fmt.Sprintf("SELECT COUNT(*) FROM %s", table)
+	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)
@@ -143,45 +168,175 @@ func (db *DB) CountEntries(table string) (int64, error) {
 	return count, nil
 }
 
-func (db *DB) StartTransaction() (*Tx, error) {
-	tx := &Tx{Tx: new(sql.Tx)}
-	var err error
+// 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 = ?
+    `
 
-	tx.Tx, err = db.Begin()
-	if err != nil {
-		return nil, fmt.Errorf("error starting transaction: %v", err)
+	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 tx, nil
+	return user, nil
 }
 
-func (tx *Tx) CommitTransaction() error {
-	if err := tx.Commit(); err != 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 (tx *Tx) RollbackTransaction() {
-	if err := tx.Rollback(); err != nil {
-		log.Fatalf("error rolling back transaction: %v", err)
+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)
 	}
-}
 
-func (tx *Tx) UpdateAttributes(a ...*Attribute) error {
-	for _, attribute := range a {
-		query := fmt.Sprintf(`
-            UPDATE %s
-            SET %s = ?
-            WHERE id = ?
-            `, attribute.Table, attribute.AttName)
-		if _, err := tx.Exec(query, attribute.Value, attribute.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 %v in DB: %v", attribute.AttName, 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 nil
+	return tags, nil
 }

cmd/model/helpers.go

@@ -0,0 +1,52 @@
+package model
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+	"syscall"
+
+	"golang.org/x/term"
+)
+
+func getUsername() (string, error) {
+	user := os.Getenv("DB_USER")
+	if user == "" {
+		var err error
+		fmt.Printf("DB Benutzer: ")
+		user, err = bufio.NewReader(os.Stdin).ReadString('\n')
+		if err != nil {
+			return "", fmt.Errorf("error reading username: %v", err)
+		}
+	}
+	return strings.TrimSpace(user), nil
+}
+
+func getPassword() (string, error) {
+	pass := os.Getenv("DB_PASS")
+	if pass == "" {
+		fmt.Printf("DB Passwort: ")
+		bytePass, err := term.ReadPassword(int(syscall.Stdin))
+		if err != nil {
+			return "", fmt.Errorf("error reading password: %v", err)
+		}
+		fmt.Println()
+		pass = strings.TrimSpace(string(bytePass))
+	}
+	return pass, nil
+}
+
+func getCredentials() (string, string, error) {
+	user, err := getUsername()
+	if err != nil {
+		return "", "", fmt.Errorf("error getting username: %v", err)
+	}
+
+	pass, err := getPassword()
+	if err != nil {
+		return "", "", fmt.Errorf("error getting password: %v", err)
+	}
+
+	return user, pass, nil
+}

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/model/tags.go

@@ -1,35 +0,0 @@
-package model
-
-import "fmt"
-
-type Tag struct {
-	Name string
-	ID   int64
-}
-
-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
-}

cmd/model/users.go

@@ -1,198 +0,0 @@
-package model
-
-import (
-	"fmt"
-	"log"
-	"math"
-	"math/rand/v2"
-	"time"
-
-	"golang.org/x/crypto/bcrypt"
-)
-
-const (
-	Admin = iota
-	Editor
-	Writer
-)
-
-type User struct {
-	UserName  string
-	FirstName string
-	LastName  string
-	ID        int64
-	Role      int
-}
-
-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, bool) {
-	var id int64
-
-	query := `
-    SELECT id
-    FROM users
-    WHERE username = ?
-    `
-	row := db.QueryRow(query, userName)
-	if err := row.Scan(&id); err != nil {
-		return 0, false
-	}
-
-	return id, true
-}
-
-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 (tx *Tx) ChangePassword(id int64, oldPass, newPass string) error {
-	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)
-	}
-
-	return 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) UpdateUserAttributes(id int64, user, first, last, oldPass, newPass, newPass2 string) error {
-	passwordEmpty := true
-	if len(newPass) > 0 || len(newPass2) > 0 {
-		if newPass != newPass2 {
-			return fmt.Errorf("error: passwords do not match")
-		}
-		passwordEmpty = false
-	}
-
-	tx := new(Tx)
-	var err error
-
-	for i := 0; i < TxMaxRetries; i++ {
-		err := func() error {
-			tx.Tx, err = db.Begin()
-			if err != nil {
-				return fmt.Errorf("error starting transaction: %v", err)
-			}
-
-			if !passwordEmpty {
-				if err = tx.ChangePassword(id, oldPass, newPass); err != nil {
-					if rollbackErr := tx.Rollback(); rollbackErr != nil {
-						log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
-					}
-					return fmt.Errorf("error changing password: %v", err)
-				}
-			}
-
-			if err = tx.UpdateAttributes(
-				&Attribute{Table: "users", ID: id, AttName: "username", Value: user},
-				&Attribute{Table: "users", ID: id, AttName: "first_name", Value: first},
-				&Attribute{Table: "users", ID: id, AttName: "last_name", Value: last},
-			); err != nil {
-				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("error: transaction error: %v, rollback error: %v", err, rollbackErr)
-				}
-				return fmt.Errorf("error updating attributes in DB: %v", err)
-			}
-
-			if err = tx.Commit(); err != nil {
-				return fmt.Errorf("error committing transaction: %v", err)
-			}
-
-			return nil
-		}()
-		if err == nil {
-			return nil
-		}
-
-		log.Println(err)
-		waitTime := time.Duration(math.Pow(2, float64(i))) * time.Second
-		jitter := time.Duration(rand.IntN(1000)) * time.Millisecond
-		time.Sleep(waitTime + jitter)
-	}
-
-	return fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
-}

cmd/view/admin.go

@@ -11,11 +11,19 @@ import (
 	"streifling.com/jason/cpolis/cmd/model"
 )
 
-type UserData struct {
+type AddUserData struct {
 	*model.User
 	Msg string
 }
 
+func inputsEmpty(user *model.User, pass, pass2 string) bool {
+	return len(user.UserName) == 0 ||
+		len(user.FirstName) == 0 ||
+		len(user.LastName) == 0 ||
+		len(pass) == 0 ||
+		len(pass2) == 0
+}
+
 func checkUserStrings(user *model.User) (string, int, bool) {
 	userLen := 15
 	nameLen := 50
@@ -45,7 +53,7 @@ func AddUser(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 			return
 		}
 
-		htmlData := UserData{
+		htmlData := AddUserData{
 			User: &model.User{
 				UserName:  r.PostFormValue("username"),
 				FirstName: r.PostFormValue("first-name"),
@@ -56,8 +64,7 @@ func AddUser(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 		pass := r.PostFormValue("password")
 		pass2 := r.PostFormValue("password2")
 
-		if len(htmlData.UserName) == 0 || len(htmlData.FirstName) == 0 ||
-			len(htmlData.LastName) == 0 || len(pass) == 0 || len(pass2) == 0 {
+		if inputsEmpty(htmlData.User, pass, pass2) {
 			htmlData.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", htmlData)
@@ -86,7 +93,7 @@ func AddUser(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 			return
 		}
 
-		num, err := db.CountEntries("users")
+		num, err := db.CountEntries()
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -119,94 +126,3 @@ func AddUser(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", 0)
 	}
 }
-
-func EditUser(db *model.DB, s *control.CookieStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		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)
-		}
-
-		user, err := db.GetUser(session.Values["id"].(int64))
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		tmpl, err := template.ParseFiles("web/templates/edit-user.html")
-		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", user)
-	}
-}
-
-func UpdateUser(db *model.DB, s *control.CookieStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		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)
-		}
-
-		userData := UserData{
-			User: &model.User{
-				ID:        session.Values["id"].(int64),
-				UserName:  r.PostFormValue("username"),
-				FirstName: r.PostFormValue("first-name"),
-				LastName:  r.PostFormValue("last-name"),
-			},
-		}
-		oldPass := r.PostFormValue("old-password")
-		newPass := r.PostFormValue("password")
-		newPass2 := r.PostFormValue("password2")
-
-		if len(userData.UserName) == 0 || len(userData.FirstName) == 0 ||
-			len(userData.LastName) == 0 {
-			userData.Msg = "Alle Felder mit * müssen ausgefüllt sein."
-			tmpl, err := template.ParseFiles("web/templates/edit-user.html")
-			tmpl = template.Must(tmpl, err)
-			tmpl.ExecuteTemplate(w, "page-content", userData.Msg)
-			return
-		}
-
-		userString, stringLen, ok := checkUserStrings(userData.User)
-		if !ok {
-			userData.Msg = fmt.Sprint(userString, " ist zu lang. Maximal ",
-				stringLen, " Zeichen erlaubt.")
-			tmpl, err := template.ParseFiles("web/templates/edit-user.html")
-			tmpl = template.Must(tmpl, err)
-			tmpl.ExecuteTemplate(w, "page-content", userData)
-			return
-		}
-
-		if id, ok := db.GetID(userData.UserName); ok {
-			if id != userData.ID {
-				userData.Msg = "Benutzername bereits vergeben."
-				userData.UserName = ""
-				tmpl, err := template.ParseFiles("web/templates/edit-user.html")
-				tmpl = template.Must(tmpl, err)
-				tmpl.ExecuteTemplate(w, "page-content", userData)
-				return
-			}
-		}
-
-		if err = db.UpdateUserAttributes(
-			userData.ID,
-			userData.UserName,
-			userData.FirstName,
-			userData.LastName,
-			oldPass,
-			newPass,
-			newPass2); err != nil {
-			userData.Msg = "Aktualisierung der Benutzerdaten fehlgeschlagen."
-			tmpl, err := template.ParseFiles("web/templates/edit-user.html")
-			template.Must(tmpl, err).ExecuteTemplate(w, "page-content", userData)
-		}
-
-		tmpl, err := template.ParseFiles("web/templates/hub.html")
-		tmpl = template.Must(tmpl, err)
-		tmpl.ExecuteTemplate(w, "page-content", session.Values["role"].(int))
-	}
-}

cmd/view/articles.go

@@ -5,13 +5,12 @@ import (
 	"log"
 	"net/http"
 	"strconv"
-	"time"
 
 	"streifling.com/jason/cpolis/cmd/control"
 	"streifling.com/jason/cpolis/cmd/model"
 )
 
-func ShowHub(db *model.DB, s *control.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 {
@@ -21,7 +20,7 @@ func ShowHub(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 		}
 
 		tmpl, err := template.ParseFiles("web/templates/hub.html")
-		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", session.Values["role"].(int))
+		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", session.Values["role"])
 	}
 }
 
@@ -39,8 +38,32 @@ func WriteArticle(db *model.DB) http.HandlerFunc {
 	}
 }
 
-func SubmitArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
+func FinishArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+		article := new(model.Article)
+		var err error
+
+		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 = control.ConvertToPlain(r.PostFormValue("editor-desc"))
+		if err != nil {
+			log.Println(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		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")
@@ -48,15 +71,7 @@ func SubmitArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 			template.Must(tmpl, err).ExecuteTemplate(w, "page-content", msg)
 		}
 
-		article := &model.Article{
-			Title:       r.PostFormValue("article-title"),
-			Description: r.PostFormValue("article-description"),
-			Content:     r.PostFormValue("article-content"),
-			Published:   false,
-			Rejected:    false,
-			AuthorID:    session.Values["id"].(int64),
-		}
-
+		article.AuthorID = session.Values["id"].(int64)
 		article.ID, err = db.AddArticle(article)
 		if err != nil {
 			log.Println(err)
@@ -87,101 +102,21 @@ func SubmitArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	}
 }
 
-func ResubmitArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		id, err := strconv.ParseInt(r.PostFormValue("article-id"), 10, 64)
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		title := r.PostFormValue("article-title")
-		description := r.PostFormValue("article-description")
-		content := r.PostFormValue("article-content")
-
-		if err := db.UpdateAttributes(
-			&model.Attribute{Table: "articles", ID: id, AttName: "title", Value: title},
-			&model.Attribute{Table: "articles", ID: id, AttName: "description", Value: description},
-			&model.Attribute{Table: "articles", ID: id, AttName: "content", Value: content},
-			&model.Attribute{Table: "articles", ID: id, AttName: "rejected", Value: false},
-		); 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)
-		}
-
-		tmpl, err := template.ParseFiles("web/templates/hub.html")
-		tmpl = template.Must(tmpl, err)
-		tmpl.ExecuteTemplate(w, "page-content", session.Values["role"])
-	}
-}
-
 func ShowUnpublishedArticles(db *model.DB) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		unpublishedArticles, err := db.GetCertainArticles(false, false)
+		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")
-		tmpl = template.Must(tmpl, err)
-		tmpl.ExecuteTemplate(w, "page-content", unpublishedArticles)
+		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", articles)
 	}
 }
 
-func ShowRejectedArticles(db *model.DB, s *control.CookieStore) http.HandlerFunc {
+func ReviewArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		type htmlData struct {
-			MyIDs            map[int64]bool
-			RejectedArticles []*model.Article
-		}
-		data := new(htmlData)
-
-		session, err := s.Get(r, "cookie")
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		data.RejectedArticles, err = db.GetCertainArticles(false, true)
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		data.MyIDs = make(map[int64]bool)
-		for _, article := range data.RejectedArticles {
-			if article.AuthorID == session.Values["id"].(int64) {
-				data.MyIDs[article.ID] = true
-			}
-		}
-
-		tmpl, err := template.ParseFiles("web/templates/rejected-articles.html")
-		tmpl = template.Must(tmpl, err)
-		tmpl.ExecuteTemplate(w, "page-content", data)
-	}
-}
-
-func ReviewUnpublishedArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		type htmlData struct {
-			Article *model.Article
-			Tags    []*model.Tag
-		}
-		data := new(htmlData)
-
 		id, err := strconv.ParseInt(r.PostFormValue("id"), 10, 64)
 		if err != nil {
 			log.Println(err)
@@ -189,70 +124,23 @@ func ReviewUnpublishedArticle(db *model.DB, s *control.CookieStore) http.Handler
 			return
 		}
 
-		data.Article, err = db.GetArticle(id)
+		article, err := db.GetArticle(id)
 		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+			tmpl, err := template.ParseFiles("web/templates/to-be-published.html")
+			template.Must(tmpl, err).ExecuteTemplate(w, "page-content", article)
 			return
 		}
 
-		data.Tags, err = db.GetArticleTags(id)
-		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)
+		// }
 
 		tmpl, err := template.ParseFiles("web/templates/to-be-published.html")
 		tmpl = template.Must(tmpl, err)
-		tmpl.ExecuteTemplate(w, "page-content", data)
-	}
-}
-
-func ReviewRejectedArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		type htmlData struct {
-			Selected map[int64]bool
-			Article  *model.Article
-			Tags     []*model.Tag
-		}
-		data := new(htmlData)
-
-		id, err := strconv.ParseInt(r.PostFormValue("id"), 10, 64)
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		data.Article, err = db.GetArticle(id)
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		data.Tags, err = db.GetTagList()
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		selectedTags, err := db.GetArticleTags(id)
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		data.Selected = make(map[int64]bool)
-		for _, tag := range selectedTags {
-			data.Selected[tag.ID] = true
-		}
-
-		tmpl, err := template.ParseFiles("web/templates/rework-article.html")
-		tmpl = template.Must(tmpl, err)
-		tmpl.ExecuteTemplate(w, "page-content", data)
+		tmpl.ExecuteTemplate(w, "page-content", article)
 	}
 }
 
@@ -272,45 +160,7 @@ func PublishArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 			template.Must(tmpl, err).ExecuteTemplate(w, "page-content", msg)
 		}
 
-		if err = db.UpdateAttributes(
-			&model.Attribute{Table: "articles", ID: id, AttName: "published", Value: true},
-			&model.Attribute{Table: "articles", ID: id, AttName: "rejected", Value: false},
-			&model.Attribute{Table: "articles", ID: id, AttName: "created", Value: time.Now().Format("2006-01-02 15:04:05")},
-		); err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		tmpl, err := template.ParseFiles("web/templates/hub.html")
-		tmpl = template.Must(tmpl, err)
-		tmpl.ExecuteTemplate(w, "page-content", session.Values["role"])
-	}
-}
-
-func RejectArticle(db *model.DB, s *control.CookieStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		id, err := strconv.ParseInt(r.PostFormValue("id"), 10, 64)
-		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)
-		}
-
-		if err = db.UpdateAttributes(
-			&model.Attribute{Table: "articles", ID: id, AttName: "rejected", Value: true},
-		); err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
+		db.UpdateAttribute("articles", id, "published", true)
 
 		tmpl, err := template.ParseFiles("web/templates/hub.html")
 		tmpl = template.Must(tmpl, err)

cmd/view/rss.go

@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"git.streifling.com/jason/rss"
-	"streifling.com/jason/cpolis/cmd/control"
 	"streifling.com/jason/cpolis/cmd/model"
 )
 
@@ -20,7 +19,7 @@ func ShowRSS(db *model.DB, title, link, desc string) http.HandlerFunc {
 			Items:       make([]*rss.Item, 0),
 		}
 
-		articles, err := db.GetCertainArticles(true, false)
+		articles, err := db.GetCertainArticles(true)
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -46,33 +45,12 @@ func ShowRSS(db *model.DB, title, link, desc string) http.HandlerFunc {
 				return
 			}
 
-			articleTitle, err := control.ConvertToPlain(article.Title)
-			if err != nil {
-				log.Println(err)
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-				return
-			}
-
-			articleDescription, err := control.ConvertToPlain(article.Description)
-			if err != nil {
-				log.Println(err)
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-				return
-			}
-
-			articleContent, err := control.ConvertToHTML(article.Content)
-			if err != nil {
-				log.Println(err)
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-				return
-			}
-
 			channel.Items = append(channel.Items, &rss.Item{
-				Title:       articleTitle,
+				Title:       article.Title,
 				Author:      user.FirstName + user.LastName,
 				PubDate:     article.Created.Format(time.RFC1123Z),
-				Description: articleDescription,
-				Content:     &rss.Content{Value: articleContent},
+				Description: article.Desc,
+				Content:     &rss.Content{Value: article.Content},
 				Categories:  tagNames,
 			})
 		}

cmd/view/sessions.go

@@ -29,7 +29,7 @@ func saveSession(w http.ResponseWriter, r *http.Request, s *control.CookieStore,
 
 func HomePage(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		numRows, err := db.CountEntries("users")
+		numRows, err := db.CountEntries()
 		if err != nil {
 			log.Fatalln(err)
 		}
@@ -59,9 +59,10 @@ func Login(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 		userName := r.PostFormValue("username")
 		password := r.PostFormValue("password")
 
-		id, ok := db.GetID(userName)
-		if !ok {
-			http.Error(w, fmt.Sprintf("no such user: %v", userName), http.StatusInternalServerError)
+		id, err := db.GetID(userName)
+		if err != nil {
+			log.Println(err)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 
@@ -88,25 +89,3 @@ func Login(db *model.DB, s *control.CookieStore) http.HandlerFunc {
 		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", user.Role)
 	}
 }
-
-func Logout(s *control.CookieStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		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.Options.MaxAge = -1
-
-		if err = session.Save(r, w); err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		tmpl, err := template.ParseFiles("web/templates/login.html")
-		template.Must(tmpl, err).ExecuteTemplate(w, "page-content", nil)
-	}
-}

web/templates/edit-user.html

@@ -1,13 +0,0 @@
-{{define "page-content"}}
-<form>
-    <input name="username" type="text" value="{{.UserName}}" />
-    <input name="first-name" type="text" value="{{.FirstName}}" />
-    <input name="last-name" type="text" value="{{.LastName}}" />
-
-    <input name="old-password" placeholder="Altes Passwort" type="password" />
-    <input name="password" placeholder="Neues Passwort" type="password" />
-    <input name="password2" placeholder="Wiederholen" type="password" />
-
-    <input type="submit" value="Aktualisieren" hx-post="/update-user/" hx-target="#page-content" />
-</form>
-{{end}}

web/templates/editor.html

@@ -1,13 +1,17 @@
 {{define "page-content"}}
 <h2>Editor</h2>
 <form>
-    <input name="article-title" placeholder="Titel" type="text" />
-    <textarea name="article-description" placeholder="Beschreibung"></textarea>
-    <textarea name="article-content" placeholder="Artikel"></textarea>
+    <input name="editor-title" placeholder="Titel" type="text" />
+    <textarea name="editor-desc" placeholder="Beschreibung"></textarea>
+    <textarea name="editor-text" placeholder="Artikel"></textarea>
     {{range .}}
     <input id="{{.Name}}" name="tags" type="checkbox" value="{{.ID}}" />
     <label for="{{.Name}}">{{.Name}}</label>
     {{end}}
-    <input type="submit" value="Senden" hx-post="/submit-article/" hx-target="#page-content" />
+    <input type="submit" value="Senden" hx-post="/finish-article/" hx-target="#page-content" />
 </form>
 {{end}}
+
+{{define "html-result"}}
+{{.}}
+{{end}}

web/templates/hub.html

@@ -1,9 +1,7 @@
 {{define "page-content"}}
 <h2>Hub</h2>
 <button hx-get="/write-article/" hx-target="#page-content">Artikel schreiben</button>
-<button hx-get="/rejected-articles/" hx-target="#page-content">Abgelehnte Artikel</button>
 <button hx-get="/rss/" hx-target="#page-content">RSS Feed</button>
-<button hx-get="/edit-user/" hx-target="#page-content">Benutzer bearbeiten</button>
 {{if lt . 2}}
 <button hx-get="/unpublished-articles/" hx-target="#page-content">Unveröffentlichte Artikel</button>
 <button hx-get="/create-tag/" hx-target="#page-content">Neuer Tag</button>

web/templates/index.html

@@ -9,22 +9,13 @@
 </head>
 
 <body>
-    <header>
-        <h1>Orient Editor</h1>
-        <button hx-get="logout" hx-target="#page-content">Abmelden</button>
-    </header>
+    <h1>Orient Editor</h1>
 
-    <main>
-        <div id="page-content">
-            {{template "page-content" .}}
-        </div>
+    <div id="page-content">
+        {{template "page-content" .}}
+    </div>
 
-        <script src="web/static/js/htmx.min.js"></script>
-    </main>
-
-    <footer>
-        <p>&copy; 2024 Jason Streifling. Alle Rechte vorbehalten.</p>
-    </footer>
+    <script src="web/static/js/htmx.min.js"></script>
 </body>
 
 </html>

web/templates/rejected-articles.html

@@ -1,12 +0,0 @@
-{{define "page-content"}}
-<form>
-    {{range .RejectedArticles}}
-    {{if index $.MyIDs .ID}}
-    <input required id="{{.ID}}" name="id" type="radio" value="{{.ID}}" />
-    <label for="{{.ID}}">{{.Title}}</label>
-    {{end}}
-    {{end}}
-    <input type="submit" value="Auswählen" hx-post="/review-rejected-article/" hx-target="#page-content" />
-</form>
-<button hx-get="/hub/" hx-target="#page-content">Zurück</button>
-{{end}}

web/templates/rework-article.html

@@ -1,16 +0,0 @@
-{{define "page-content"}}
-<h2>Editor</h2>
-<form>
-    <input name="article-title" placeholder="Titel" type="text" value="{{.Article.Title}}" />
-    <textarea name="article-description" placeholder="Beschreibung">{{.Article.Description}}</textarea>
-    <textarea name="article-content" placeholder="Artikel">{{.Article.Content}}</textarea>
-    <input name="article-id" type="hidden" value="{{.Article.ID}}" />
-
-    {{range .Tags}}
-    <input id="tag-{{.Name}}" name="tags" type="checkbox" value="{{.ID}}" {{if index $.Selected .ID}}checked{{end}} />
-    <label for="tag-{{.Name}}">{{.Name}}</label>
-    {{end}}
-
-    <input type="submit" value="Senden" hx-post="/resubmit-article/" hx-target="#page-content" />
-</form>
-{{end}}

web/templates/to-be-published.html

@@ -1,19 +1,11 @@
 {{define "page-content"}}
 <form>
-    <h2>{{.Article.Title}}</h2>
-    <p>{{.Article.Description}}</p>
-    {{.Article.Content}}
-
-    <p>
-    {{range .Tags}}
-    {{.Name}}
-    {{end}}
-    </p>
-
-    <input name="id" type="hidden" value="{{.Article.ID}}" />
+    <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>
-
 <button hx-get="/hub/" hx-target="#page-content">Zurück</button>
 {{end}}

web/templates/unpublished-articles.html

@@ -4,7 +4,7 @@
     <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-unpublished-article/" hx-target="#page-content" />
+    <input type="submit" value="Auswählen" hx-post="/review-article/" hx-target="#page-content" />
 </form>
 <button hx-get="/hub/" hx-target="#page-content">Zurück</button>
 {{end}}