cpolis/cmd/frontend/articles.go

package frontend

import (
	"fmt"
	"html/template"
	"log"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	b "streifling.com/jason/cpolis/cmd/backend"
)

const (
	EditMode = iota
	PreviewMode
)

const (
	None = iota
	Author
	Contributor
)

type ArticleUser struct {
	*b.User
	ArticleRole int
}

type EditorHTMLData struct {
	Selected     map[int64]bool
	Content      string
	Action       string
	ActionTitle  string
	ActionButton string
	Image        string
	HTMLContent  template.HTML
	Article      *b.Article
	Tags         []*b.Tag
	ArticleUsers map[string]*ArticleUser // A map is way more efficient in ReviewRejectedArticle()
	Creator      *ArticleUser
	Authors      []*b.User
	Contributors []*b.User
}

func WriteArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := GetSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		var data *EditorHTMLData
		if session.Values["article"] == nil {
			data = &EditorHTMLData{Action: "submit", Article: new(b.Article), ArticleUsers: make(map[string]*ArticleUser)}
		} else {
			data = session.Values["article"].(*EditorHTMLData)
		}

		users, err := db.GetAllUsers(c)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		for _, user := range users {
			data.ArticleUsers[fmt.Sprint(user.LastName, user.FirstName, user.ID)] = &ArticleUser{User: user, ArticleRole: None}
		}

		creator, err := db.GetUser(c, session.Values["id"].(int64))
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Creator = data.ArticleUsers[fmt.Sprint(creator.LastName, creator.FirstName, creator.ID)]
		delete(data.ArticleUsers, fmt.Sprint(creator.LastName, creator.FirstName, creator.ID))

		data.Tags, err = db.GetTagList()
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/editor.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func SubmitArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := GetSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		session.Values["article"] = nil
		if err = session.Save(r, w); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		article := &b.Article{
			Title:         r.PostFormValue("article-title"),
			BannerLink:    r.PostFormValue("article-banner-url"),
			Summary:       r.PostFormValue("article-summary"),
			CreatorID:     session.Values["id"].(int64),
			Published:     false,
			Rejected:      false,
			IsInIssue:     r.PostFormValue("issue") == "on",
			AutoGenerated: false,
			EditedID:      0,
		}

		if len(article.Title) == 0 {
			http.Error(w, "Bitte den Titel eingeben.", http.StatusBadRequest)
			return
		}
		if len(article.Summary) == 0 {
			http.Error(w, "Bitte die Beschreibung eingeben.", http.StatusBadRequest)
			return
		}

		r.ParseForm()
		authors := make([]int64, 0)
		contributors := make([]int64, 0)

		for key, values := range r.Form {
			if strings.HasPrefix(key, "user-") && len(values) > 0 {
				id, err := strconv.ParseInt(strings.Split(key, "-")[1], 10, 64)
				if err != nil {
					log.Println(err)
					http.Error(w, err.Error(), http.StatusBadRequest)
					return
				}

				switch values[0] {
				case "author":
					authors = append(authors, id)
				case "contributor":
					contributors = append(contributors, id)
				}
			}
		}

		if r.PostFormValue("creator") == "contributor" {
			contributors = append(contributors, article.CreatorID)
		} else {
			authors = append(authors, article.CreatorID)
		}
		if len(authors) == 0 {
			http.Error(w, "Es muss mindestens einen Autor geben.", http.StatusBadRequest)
			return
		}

		article.ID, err = db.AddArticle(article)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		content := []byte(r.PostFormValue("article-content"))
		if len(content) == 0 {
			http.Error(w, "Bitte den Artikel eingeben.", http.StatusBadRequest)
			return
		}
		if err := b.WriteArticleToFile(c, article.ID, content); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.WriteArticleAuthors(article.ID, authors); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		if len(contributors) > 0 {
			if err = db.WriteArticleContributors(article.ID, contributors); err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
		}

		tags := make([]int64, 0)
		for _, tag := range r.Form["tags"] {
			tagID, err := strconv.ParseInt(tag, 10, 64)
			if err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusBadRequest)
				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
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ResubmitArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := GetSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		article := &b.Article{
			Title:      r.PostFormValue("article-title"),
			BannerLink: r.PostFormValue("article-banner-url"),
			Summary:    r.PostFormValue("article-summary"),
			CreatorID:  session.Values["id"].(int64),
			IsInIssue:  r.PostFormValue("issue") == "on",
		}

		if len(article.Title) == 0 {
			http.Error(w, "Bitte den Titel eingeben.", http.StatusBadRequest)
			return
		}
		if len(article.Summary) == 0 {
			http.Error(w, "Bitte die Beschreibung eingeben.", http.StatusBadRequest)
			return
		}

		r.ParseForm()
		authors := make([]int64, 0)
		contributors := make([]int64, 0)

		for key, values := range r.Form {
			if strings.HasPrefix(key, "user-") && len(values) > 0 {
				id, err := strconv.ParseInt(strings.Split(key, "-")[1], 10, 64)
				if err != nil {
					log.Println(err)
					http.Error(w, err.Error(), http.StatusBadRequest)
					return
				}

				switch values[0] {
				case "author":
					authors = append(authors, id)
				case "contributor":
					contributors = append(contributors, id)
				}
			}
		}

		if r.PostFormValue("creator") == "contributor" {
			contributors = append(contributors, article.CreatorID)
		} else {
			authors = append(authors, article.CreatorID)
		}
		if len(authors) == 0 {
			http.Error(w, "Es muss mindestens einen Autor geben.", http.StatusBadRequest)
			return
		}

		article.ID, err = strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		content := r.PostFormValue("article-content")
		if len(content) == 0 {
			http.Error(w, "Bitte den Artikel eingeben.", http.StatusBadRequest)
			return
		}
		contentLink := fmt.Sprint(c.ArticleDir, "/", article.ID, ".md")
		if err = os.WriteFile(contentLink, []byte(content), 0644); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.UpdateAttributes(
			&b.Attribute{Table: "articles", ID: article.ID, AttName: "title", Value: article.Title},
			&b.Attribute{Table: "articles", ID: article.ID, AttName: "banner_link", Value: article.BannerLink},
			&b.Attribute{Table: "articles", ID: article.ID, AttName: "summary", Value: article.Summary},
			&b.Attribute{Table: "articles", ID: article.ID, AttName: "rejected", Value: false},
			&b.Attribute{Table: "articles", ID: article.ID, AttName: "is_in_issue", Value: article.IsInIssue},
		); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.UpdateArticleAuthors(article.ID, authors); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		if len(contributors) > 0 {
			if err = db.UpdateArticleContributors(article.ID, contributors); err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
		}

		tags := make([]int64, 0)
		for _, tag := range r.Form["tags"] {
			tagID, err := strconv.ParseInt(tag, 10, 64)
			if err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			tags = append(tags, tagID)
		}
		if err = db.UpdateArticleTags(article.ID, tags); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ShowUnpublishedUnrejectedAndPublishedRejectedArticles(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := GetSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		rejectedArticles, err := db.GetCertainArticles("rejected", true)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		articles := make([]*b.Article, 0)
		for _, article := range rejectedArticles {
			if article.Published {
				articles = append(articles, article)
			}
		}

		unpublishedArticles, err := db.GetCertainArticles("published", false)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		for _, article := range unpublishedArticles {
			if !article.Rejected {
				articles = append(articles, article)
			}
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/unpublished-articles.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", articles); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ShowRejectedArticles(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := GetSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct {
			MyIDs            map[int64]bool
			RejectedArticles []*b.Article
		})

		data.RejectedArticles, err = db.GetCertainArticles("rejected", 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.CreatorID == session.Values["id"].(int64) {
				data.MyIDs[article.ID] = true
			}
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/rejected-articles.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ReviewRejectedArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := GetSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(EditorHTMLData)
		data.Article, err = db.GetArticle(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data.Image = data.Article.BannerLink

		articleAbsName := fmt.Sprint(c.ArticleDir, "/", data.Article.ID, ".md")
		content, err := os.ReadFile(articleAbsName)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Content = string(content)

		data.Tags, err = db.GetTagList()
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data.ArticleUsers = make(map[string]*ArticleUser)
		users, err := db.GetAllUsers(c)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		for _, user := range users {
			data.ArticleUsers[fmt.Sprint(user.LastName, user.FirstName, user.ID)] = &ArticleUser{User: user, ArticleRole: None}
		}

		authors, err := db.GetArticleAuthors(c, data.Article.ID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		for _, author := range authors {
			data.ArticleUsers[fmt.Sprint(author.LastName, author.FirstName, author.ID)].ArticleRole = Author
		}

		contributors, err := db.GetArticleContributors(c, data.Article.ID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		for _, contributor := range contributors {
			data.ArticleUsers[fmt.Sprint(contributor.LastName, contributor.FirstName, contributor.ID)].ArticleRole = Contributor
		}

		creator, err := db.GetUser(c, session.Values["id"].(int64))
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Creator = data.ArticleUsers[fmt.Sprint(creator.LastName, creator.FirstName, creator.ID)]
		delete(data.ArticleUsers, fmt.Sprint(creator.LastName, creator.FirstName, creator.ID))

		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
		}

		data.Action = fmt.Sprint("resubmit/", data.Article.ID)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/editor.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func PublishArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := GetSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}

		article, err := db.GetArticle(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.AddArticleToCurrentIssue(article.ID); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.UpdateAttributes(
			&b.Attribute{Table: "articles", ID: article.ID, AttName: "published", Value: true},
			&b.Attribute{Table: "articles", ID: article.ID, AttName: "rejected", Value: false},
			&b.Attribute{Table: "articles", ID: article.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
		}

		if article.EditedID != 0 {
			oldArticle, err := db.GetArticle(article.EditedID)
			if err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			if err = db.DeleteArticle(oldArticle.ID); err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			if err = os.Remove(fmt.Sprint(c.ArticleDir, "/", oldArticle.ID, ".md")); err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			if err = db.UpdateAttributes(&b.Attribute{Table: "articles", ID: article.ID, AttName: "edited_id", Value: 0}); err != nil {
				log.Println(err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
		}

		feed, err := b.GenerateAtomFeed(c, db)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		if err = b.SaveAtomFeed(c.AtomFile, feed); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func RejectArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := GetSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.UpdateAttributes(&b.Attribute{Table: "articles", ID: id, AttName: "rejected", Value: true}); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ShowCurrentIssue(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := GetSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		articles, err := db.GetCurrentIssueArticles()
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/current-issue.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", articles); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ShowPublishedArticles(c *b.Config, db *b.DB, s *b.CookieStore, action string) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := GetSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct {
			Action   string
			Articles []*b.Article
		})
		data.Action = action

		publishedArticles, err := db.GetCertainArticles("published", true)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		for _, article := range publishedArticles {
			if !article.AutoGenerated {
				data.Articles = append(data.Articles, article)
			}
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/published-articles.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func ReviewArticle(c *b.Config, db *b.DB, s *b.CookieStore, action, title, button string) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := GetSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		article, err := db.GetArticle(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := &EditorHTMLData{
			Article: &b.Article{
				ID:        id,
				IsInIssue: article.IsInIssue,
			},
			Action:       action,
			ActionTitle:  title,
			ActionButton: button,
		}

		data.Article.Title, err = b.ConvertToPlain(article.Title)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data.Image = article.BannerLink

		data.Article.Summary, err = b.ConvertToPlain(article.Summary)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		articleAbsName := fmt.Sprint(c.ArticleDir, "/", article.ID, ".md")
		content, err := os.ReadFile(articleAbsName)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Content, err = b.ConvertToHTML(string(content))
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.HTMLContent = template.HTML(data.Content)

		data.Authors, err = db.GetArticleAuthors(c, data.Article.ID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		sortUsersByName(data.Authors)

		data.Contributors, err = db.GetArticleContributors(c, data.Article.ID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		sortUsersByName(data.Contributors)

		data.Tags, err = db.GetArticleTags(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/review-article.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func DeleteArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := GetSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.DeleteArticle(id); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = os.Remove(fmt.Sprint(c.ArticleDir, "/", id, ".md")); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		feed, err := b.GenerateAtomFeed(c, db)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		if err = b.SaveAtomFeed(c.AtomFile, feed); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
		tmpl = template.Must(tmpl, err)
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func AllowEditArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		session, err := GetSession(w, r, c, s)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		oldID, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		oldArticle, err := db.GetArticle(oldID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		newArticle := *oldArticle
		newArticle.Published = false
		newArticle.Rejected = true
		newArticle.EditedID = oldArticle.ID

		newArticle.ID, err = db.AddArticle(&newArticle)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		if err = db.UpdateAttributes(&b.Attribute{Table: "articles", ID: oldArticle.ID, AttName: "edited_id", Value: newArticle.ID}); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		src := fmt.Sprint(c.ArticleDir, "/", oldArticle.ID, ".md")
		dst := fmt.Sprint(c.ArticleDir, "/", newArticle.ID, ".md")
		if err = b.CopyFile(src, dst); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		authors, err := db.GetArticleAuthors(c, oldArticle.ID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		authorIDs := make([]int64, len(authors))
		for i, author := range authors {
			authorIDs[i] = author.ID
		}
		if err = db.WriteArticleAuthors(newArticle.ID, authorIDs); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		contributors, err := db.GetArticleContributors(c, oldArticle.ID)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		contributorIDs := make([]int64, len(contributors))
		for i, contributor := range contributors {
			contributorIDs[i] = contributor.ID
		}
		if err = db.WriteArticleContributors(newArticle.ID, contributorIDs); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(struct{ Role int })
		data.Role = session.Values["role"].(int)

		tmpl := template.Must(template.ParseFiles(c.WebDir + "/templates/hub.html"))
		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func EditArticle(c *b.Config, db *b.DB, s *b.CookieStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if _, err := GetSession(w, r, c, s); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data := new(EditorHTMLData)

		data.Article, err = db.GetArticle(id)
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		data.Image = data.Article.BannerLink

		content, err := os.ReadFile(fmt.Sprint(c.ArticleDir, "/", data.Article.ID, ".md"))
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		data.Content = string(content)

		data.Tags, err = db.GetArticleTags(data.Article.ID)
		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
		}

		data.Action = fmt.Sprint("save/", data.Article.ID)

		tmpl, err := template.ParseFiles(c.WebDir + "/templates/editor.html")
		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}