Add logging for atom generation

cmd/backend/articles.go

@@ -115,6 +115,31 @@ func (db *DB) GetArticle(id int64) (*Article, error) {
 	return article, nil
 }
 
+func (db *DB) GetArticleByUUID(u uuid.UUID) (*Article, error) {
+	query := `
+    SELECT id, title, created, banner_link, summary, published, creator_id, issue_id, edited_id, clicks, is_in_issue, auto_generated
+    FROM articles
+    WHERE uuid = ?
+    `
+	row := db.QueryRow(query, u.String())
+
+	article := new(Article)
+	var created []byte
+	var err error
+
+	if err := row.Scan(&article.ID, &article.Title, &created, &article.BannerLink, &article.Summary, &article.Published, &article.CreatorID, &article.IssueID, &article.EditedID, &article.Clicks, &article.IsInIssue, &article.AutoGenerated); err != nil {
+		return nil, fmt.Errorf("error scanning article row: %v", err)
+	}
+
+	article.UUID = u
+	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(attribute string, value bool) ([]*Article, error) {
 	query := fmt.Sprintf(`
     SELECT id, title, created, banner_link, summary, creator_id, issue_id, clicks, published, rejected, is_in_issue, auto_generated, uuid

cmd/backend/atom.go

@@ -3,6 +3,7 @@ package backend
 import (
 	"fmt"
 	"io"
+	"log"
 	"os"
 
 	"git.streifling.com/jason/atom"
@@ -22,73 +23,81 @@ func GenerateAtomFeed(c *Config, db *DB) (*string, error) {
 
 	articles, err := db.GetCertainArticles("published", true)
 	if err != nil {
-		return nil, fmt.Errorf("error getting published articles for Atom feed: %v", err)
+		log.Printf("Error retrieving published articles for Atom feed: %v", err)
+		return nil, fmt.Errorf("error getting published articles for Atom feed: %w", err)
 	}
 
 	for _, article := range articles {
 		articleTitle, err := ConvertToPlain(article.Title)
 		if err != nil {
-			return nil, fmt.Errorf("error converting title to plain text for Atom feed: %v", err)
+			log.Printf("Error converting article title to plain text for Atom feed: %v", err)
+			return nil, fmt.Errorf("error converting title to plain text for Atom feed: %w", err)
 		}
 		entry := atom.NewEntry(articleTitle)
-		entry.ID = atom.NewID(fmt.Sprint("urn:entry:", article.ID))
+		entry.ID = atom.NewID(fmt.Sprintf("urn:entry:%d", article.ID))
 		entry.Published = atom.NewDate(article.Created)
-		entry.Content = atom.NewContent(atom.OutOfLine, "text/html", fmt.Sprint(c.Domain, "/article/serve/", article.UUID))
+		entry.Content = atom.NewContent(atom.OutOfLine, "text/html", fmt.Sprintf("%s/article/serve/%s", c.Domain, article.UUID))
 
 		if article.AutoGenerated {
 			entry.Summary = atom.NewText("text", "automatically generated")
 		} else {
 			articleSummary, err := ConvertToPlain(article.Summary)
 			if err != nil {
-				return nil, fmt.Errorf("error converting description to plain text for Atom feed: %v", err)
+				log.Printf("Error converting article summary to plain text for Atom feed: %v", err)
+				return nil, fmt.Errorf("error converting description to plain text for Atom feed: %w", err)
 			}
 			entry.Summary = atom.NewText("text", articleSummary)
 		}
 
 		if len(article.BannerLink) > 0 {
-			linkID := entry.AddLink(atom.NewLink(c.Domain + "/image/serve/" + article.BannerLink))
+			linkID := entry.AddLink(atom.NewLink(fmt.Sprintf("%s/image/serve/%s", c.Domain, article.BannerLink)))
 			entry.Links[linkID].Rel = "enclosure"
 			entry.Links[linkID].Type = "image/webp"
 		}
 
 		authors, err := db.GetArticleAuthors(c, article.ID)
 		if err != nil {
-			return nil, fmt.Errorf("error getting article's authors for Atom feed: %v", err)
+			log.Printf("Error retrieving authors for article ID %d for Atom feed: %v", article.ID, err)
+			return nil, fmt.Errorf("error getting article's authors for Atom feed: %w", err)
 		}
 		for _, author := range authors {
 			user, err := db.GetUser(c, author.ID)
 			if err != nil {
-				return nil, fmt.Errorf("error getting user info for Atom feed: %v", err)
+				log.Printf("Error retrieving user info for author ID %d for Atom feed: %v", author.ID, err)
+				return nil, fmt.Errorf("error getting user info for Atom feed: %w", err)
 			}
 
-			authorID := entry.AddAuthor(atom.NewPerson(user.FirstName + " " + user.LastName))
-			entry.Authors[authorID].URI = c.Domain + "/image/serve/" + user.ProfilePicLink
+			authorID := entry.AddAuthor(atom.NewPerson(fmt.Sprintf("%s %s", user.FirstName, user.LastName)))
+			entry.Authors[authorID].URI = fmt.Sprintf("%s/image/serve/%s", c.Domain, user.ProfilePicLink)
 		}
 
 		contributors, err := db.GetArticleContributors(c, article.ID)
 		if err != nil {
-			return nil, fmt.Errorf("error getting article's contributors for Atom feed: %v", err)
+			log.Printf("Error retrieving contributors for article ID %d for Atom feed: %v", article.ID, err)
+			return nil, fmt.Errorf("error getting article's contributors for Atom feed: %w", err)
 		}
 		for _, contributor := range contributors {
 			user, err := db.GetUser(c, contributor.ID)
 			if err != nil {
-				return nil, fmt.Errorf("error getting user info for Atom feed: %v", err)
+				log.Printf("Error retrieving user info for contributor ID %d for Atom feed: %v", contributor.ID, err)
+				return nil, fmt.Errorf("error getting user info for Atom feed: %w", err)
 			}
 
-			contributorID := entry.AddContributor(atom.NewPerson(user.FirstName + " " + user.LastName))
-			entry.Contributors[contributorID].URI = c.Domain + "/image/serve/" + user.ProfilePicLink
+			contributorID := entry.AddContributor(atom.NewPerson(fmt.Sprintf("%s %s", user.FirstName, user.LastName)))
+			entry.Contributors[contributorID].URI = fmt.Sprintf("%s/image/serve/%s", c.Domain, user.ProfilePicLink)
 		}
 
 		tags, err := db.GetArticleTags(article.ID)
 		if err != nil {
-			return nil, fmt.Errorf("error getting tags for articles for Atom feed: %v", err)
+			log.Printf("Error retrieving tags for article ID %d for Atom feed: %v", article.ID, err)
+			return nil, fmt.Errorf("error getting tags for articles for Atom feed: %w", err)
 		}
 		for _, tag := range tags {
 			entry.AddCategory(atom.NewCategory(tag.Name))
 		}
 
 		if article.IsInIssue || article.AutoGenerated {
-			entry.AddCategory(atom.NewCategory(fmt.Sprint("Orient Express ", article.IssueID)))
+			entry.AddCategory(atom.NewCategory(fmt.Sprintf("Orient Express %d", article.IssueID)))
 		}
 		if article.AutoGenerated {
 			entry.AddCategory(atom.NewCategory("autogenerated"))
@@ -99,29 +108,39 @@ func GenerateAtomFeed(c *Config, db *DB) (*string, error) {
 	}
 
 	if err = feed.Check(); err != nil {
-		return nil, fmt.Errorf("error checking Atom feed: %v", err)
+		log.Printf("Error checking Atom feed: %v", err)
+		return nil, fmt.Errorf("error checking Atom feed: %w", err)
 	}
 
-	atom, err := feed.ToXML("UTF-8")
+	atomXML, err := feed.ToXML("UTF-8")
 	if err != nil {
-		return nil, fmt.Errorf("error converting Atom feed to XML: %v", err)
+		log.Printf("Error converting Atom feed to XML: %v", err)
+		return nil, fmt.Errorf("error converting Atom feed to XML: %w", err)
 	}
 
-	return &atom, nil
+	return &atomXML, nil
 }
 
 func SaveAtomFeed(filename string, feed *string) error {
 	file, err := os.Create(filename)
 	if err != nil {
-		return fmt.Errorf("error creating file for Atom feed: %v", err)
+		log.Printf("Error creating file for Atom feed: %v", err)
+		return fmt.Errorf("error creating file for Atom feed: %w", err)
 	}
-	defer file.Close()
+	defer func() {
+		if cerr := file.Close(); cerr != nil {
+			log.Printf("Error closing file for Atom feed: %v", cerr)
+		}
+	}()
+
 	if err = file.Chmod(0644); err != nil {
-		return fmt.Errorf("error setting permissions for Atom file: %v", err)
+		log.Printf("Error setting permissions for Atom file '%s': %v", filename, err)
+		return fmt.Errorf("error setting permissions for Atom file: %w", err)
 	}
 
 	if _, err = io.WriteString(file, *feed); err != nil {
-		return fmt.Errorf("error writing to Atom file: %v", err)
+		log.Printf("Error writing to Atom file '%s': %v", filename, err)
+		return fmt.Errorf("error writing to Atom file: %w", err)
 	}
 
 	return nil

cmd/backend/config.go

@@ -52,7 +52,7 @@ func newConfig() *Config {
 		PDFDir:            "/var/www/cpolis/pdfs",
 		PicsDir:           "/var/www/cpolis/pics",
 		Port:              ":8080",
-		Version:           "v0.15.0",
+		Version:           "v0.15.3",
 		WebDir:            "/var/www/cpolis/web",
 	}
 }
@@ -91,7 +91,7 @@ func mkFile(path string, filePerm, dirPerm fs.FileMode) (string, error) {
 		}
 
 		fileName := stringSlice[len(stringSlice)-1]
-		file, err := os.Create(dir + "/" + fileName)
+		file, err := os.Create(filepath.Join(dir, fileName))
 		if err != nil {
 			return "", fmt.Errorf("error creating %v: %v", fileName, err)
 		}
@@ -158,6 +158,10 @@ func (c *Config) setupConfig(cliConfig *Config) error {
 	if cliConfig.AESKeyFile != defaultConfig.AESKeyFile {
 		c.AESKeyFile = cliConfig.AESKeyFile
 	}
+	c.AESKeyFile, err = filepath.Abs(c.AESKeyFile)
+	if err != nil {
+		return fmt.Errorf("error setting absolute filepath for AESKeyFile: %v", err)
+	}
 	c.AESKeyFile, err = mkFile(c.AESKeyFile, 0600, 0700)
 	if err != nil {
 		return fmt.Errorf("error setting up file: %v", err)
@@ -166,6 +170,10 @@ func (c *Config) setupConfig(cliConfig *Config) error {
 	if cliConfig.ArticleDir != defaultConfig.ArticleDir {
 		c.ArticleDir = cliConfig.ArticleDir
 	}
+	c.ArticleDir, err = filepath.Abs(c.ArticleDir)
+	if err != nil {
+		return fmt.Errorf("error setting absolute filepath for ArticleDir: %v", err)
+	}
 	c.ArticleDir, err = mkDir(c.ArticleDir, 0700)
 	if err != nil {
 		return fmt.Errorf("error setting up directory: %v", err)
@@ -174,6 +182,10 @@ func (c *Config) setupConfig(cliConfig *Config) error {
 	if cliConfig.AtomFile != defaultConfig.AtomFile {
 		c.AtomFile = cliConfig.AtomFile
 	}
+	c.AtomFile, err = filepath.Abs(c.AtomFile)
+	if err != nil {
+		return fmt.Errorf("error setting absolute filepath for AtomFile: %v", err)
+	}
 	c.AtomFile, err = mkFile(c.AtomFile, 0644, 0744)
 	if err != nil {
 		return fmt.Errorf("error setting up file: %v", err)
@@ -202,6 +214,10 @@ func (c *Config) setupConfig(cliConfig *Config) error {
 	if cliConfig.FirebaseKey != defaultConfig.FirebaseKey {
 		c.FirebaseKey = cliConfig.FirebaseKey
 	}
+	c.FirebaseKey, err = filepath.Abs(c.FirebaseKey)
+	if err != nil {
+		return fmt.Errorf("error setting absolute filepath for FirebaseKey: %v", err)
+	}
 	c.FirebaseKey, err = mkFile(c.FirebaseKey, 0600, 0700)
 	if err != nil {
 		return fmt.Errorf("error setting up file: %v", err)
@@ -214,6 +230,10 @@ func (c *Config) setupConfig(cliConfig *Config) error {
 	if cliConfig.LogFile != defaultConfig.LogFile {
 		c.LogFile = cliConfig.LogFile
 	}
+	c.LogFile, err = filepath.Abs(c.LogFile)
+	if err != nil {
+		return fmt.Errorf("error setting absolute filepath for LogFile: %v", err)
+	}
 	c.LogFile, err = mkFile(c.LogFile, 0600, 0700)
 	if err != nil {
 		return fmt.Errorf("error setting up file: %v", err)
@@ -238,6 +258,10 @@ func (c *Config) setupConfig(cliConfig *Config) error {
 	if cliConfig.PDFDir != defaultConfig.PDFDir {
 		c.PDFDir = cliConfig.PDFDir
 	}
+	c.PDFDir, err = filepath.Abs(c.PDFDir)
+	if err != nil {
+		return fmt.Errorf("error setting absolute filepath for PDFDir: %v", err)
+	}
 	c.PDFDir, err = mkDir(c.PDFDir, 0700)
 	if err != nil {
 		return fmt.Errorf("error setting up directory: %v", err)
@@ -246,6 +270,10 @@ func (c *Config) setupConfig(cliConfig *Config) error {
 	if cliConfig.PicsDir != defaultConfig.PicsDir {
 		c.PicsDir = cliConfig.PicsDir
 	}
+	c.PicsDir, err = filepath.Abs(c.PicsDir)
+	if err != nil {
+		return fmt.Errorf("error setting absolute filepath for PicsDir: %v", err)
+	}
 	c.PicsDir, err = mkDir(c.PicsDir, 0700)
 	if err != nil {
 		return fmt.Errorf("error setting up directory: %v", err)
@@ -262,6 +290,10 @@ func (c *Config) setupConfig(cliConfig *Config) error {
 	if cliConfig.WebDir != defaultConfig.WebDir {
 		c.WebDir = cliConfig.WebDir
 	}
+	c.WebDir, err = filepath.Abs(c.WebDir)
+	if err != nil {
+		return fmt.Errorf("error setting absolute filepath for WebDir: %v", err)
+	}
 	c.WebDir, err = mkDir(c.WebDir, 0700)
 	if err != nil {
 		return fmt.Errorf("error setting up directory: %v", err)

cmd/backend/docx.go

@@ -14,15 +14,13 @@ import (
 func ConvertToMarkdown(c *Config, filename string) ([]byte, error) {
 	var stderr bytes.Buffer
 
-	articleID := uuid.New()
-	articleFileName := fmt.Sprint("/tmp/", articleID, ".md")
-
-	tmpDir, err := os.MkdirTemp("/tmp", "cpolis_images")
+	tmpDir, err := os.MkdirTemp(os.TempDir(), "cpolis_images")
 	if err != nil {
 		return nil, fmt.Errorf("error creating temporary directory: %v", err)
 	}
 	defer os.RemoveAll(tmpDir)
 
+	articleFileName := filepath.Join(os.TempDir(), fmt.Sprint(uuid.New(), ".md"))
 	cmd := exec.Command("pandoc", "-s", "-f", "docx", "-t", "commonmark_x", "-o", articleFileName, "--extract-media", tmpDir, filename) // TODO: Is writing to a file necessary?
 	cmd.Stderr = &stderr
 	if err = cmd.Run(); err != nil {
@@ -52,7 +50,7 @@ func ConvertToMarkdown(c *Config, filename string) ([]byte, error) {
 			return nil, fmt.Errorf("error saving image %v: %v", name, err)
 		}
 
-		articleContent = regexp.MustCompile(name).ReplaceAll(articleContent, []byte(c.PicsDir+"/"+newImageName))
+		articleContent = regexp.MustCompile(name).ReplaceAll(articleContent, []byte(c.Domain+"/image/serve/"+newImageName))
 	}
 
 	return articleContent, nil

cmd/backend/images.go

@@ -6,11 +6,9 @@ import (
 	"image"
 	"io"
 	"io/fs"
-	"log"
 	"os"
 	"path/filepath"
 	"strings"
-	"time"
 
 	"github.com/chai2010/webp"
 	"github.com/disintegration/imaging"
@@ -49,58 +47,67 @@ func SaveImage(src io.Reader, maxHeight, maxWidth int, path string) (string, err
 	return filename, nil
 }
 
-func CleanUpImages(c *Config) {
-	for {
-		if err := filepath.Walk(c.PicsDir, func(path string, info fs.FileInfo, err error) error {
-			if err != nil {
-				return err
+func CleanUpImages(c *Config, db *DB) error {
+	if err := filepath.Walk(c.PicsDir, func(path string, info fs.FileInfo, err error) error {
+		if err != nil {
+			return fmt.Errorf("error walking images filepath: %v", err)
+		}
+
+		if !info.IsDir() {
+			imageName := info.Name()
+			imagePath := path
+			imageWasFound := false
+
+			if err = filepath.Walk(c.ArticleDir, func(path string, info fs.FileInfo, err error) error {
+				if err != nil {
+					return fmt.Errorf("error walking articles filepath: %v", err)
+				}
+
+				if !info.IsDir() {
+					mdFile, err := os.Open(path)
+					if err != nil {
+						return fmt.Errorf("error opening article %v: %v", info.Name(), err)
+					}
+					defer mdFile.Close()
+
+					scanner := bufio.NewScanner(mdFile)
+
+					for scanner.Scan() {
+						if strings.Contains(scanner.Text(), imageName) {
+							imageWasFound = true
+						}
+					}
+
+					return scanner.Err()
+				}
+
+				return nil
+			}); err != nil {
+				return fmt.Errorf("error walking articles filepath: %v", err)
 			}
 
-			if !info.IsDir() {
-				imageName := info.Name()
-				absImageName := path
+			users, err := db.GetAllUsers(c)
+			if err != nil {
+				return fmt.Errorf("error getting all users: %v", err)
+			}
 
-				if err = filepath.Walk(c.ArticleDir, func(path string, info fs.FileInfo, err error) error {
-					if err != nil {
-						return err
-					}
-
-					if !info.IsDir() {
-						mdFile, err := os.Open(path)
-						if err != nil {
-							return err
-						}
-						defer mdFile.Close()
-
-						scanner := bufio.NewScanner(mdFile)
-						imageWasFound := false
-
-						for scanner.Scan() {
-							if strings.Contains(scanner.Text(), imageName) {
-								imageWasFound = true
-							}
-						}
-
-						if !imageWasFound {
-							if err = os.Remove(absImageName); err != nil {
-								return err
-							}
-						}
-
-						return scanner.Err()
-					}
-
-					return nil
-				}); err != nil {
-					return err
+			for _, user := range users {
+				if imageName == user.ProfilePicLink {
+					imageWasFound = true
 				}
 			}
 
-			return nil
-		}); err != nil {
-			log.Println(err)
+			if !imageWasFound {
+				if err = os.Remove(imagePath); err != nil {
+					return fmt.Errorf("error removing unused image: %v", err)
+				}
+			}
 		}
 
-		time.Sleep(time.Hour)
+		return nil
+	}); err != nil {
+		return fmt.Errorf("error cleaning up: %v", err)
 	}
+
+	return nil
 }

cmd/backend/users.go

@@ -37,15 +37,19 @@ type User struct {
 func readKey(filename string) ([]byte, error) {
 	key, err := os.ReadFile(filename)
 	if err != nil {
-		return nil, fmt.Errorf("error reading from aes key file: %v", err)
+		log.Printf("Error reading AES key file '%s': %v", filename, err)
+		return nil, fmt.Errorf("error reading from AES key file: %v", err)
 	}
 
 	if len(key) != 44 {
-		return nil, errors.New("key is not 32 bytes long")
+		errMsg := "key is not 32 bytes long"
+		log.Println(errMsg)
+		return nil, errors.New(errMsg)
 	}
 
 	key, err = base64.StdEncoding.DecodeString(string(key))
 	if err != nil {
+		log.Printf("Error base64 decoding key: %v", err)
 		return nil, fmt.Errorf("error base64 decoding key: %v", err)
 	}
 
@@ -55,14 +59,17 @@ func readKey(filename string) ([]byte, error) {
 func key(c *Config) ([]byte, error) {
 	key, err := readKey(c.AESKeyFile)
 	if err != nil {
+		log.Printf("Error reading key: %v", err)
 		key = make([]byte, 32)
 		if _, err := rand.Read(key); err != nil {
+			log.Printf("Error generating random key: %v", err)
 			return nil, fmt.Errorf("error generating random key: %v", err)
 		}
 
 		fileKey := make([]byte, 44)
 		base64.StdEncoding.Encode(fileKey, key)
 		if err = os.WriteFile(c.AESKeyFile, fileKey, 0600); err != nil {
+			log.Printf("Error writing key to file '%s': %v", c.AESKeyFile, err)
 			return nil, fmt.Errorf("error writing key to file: %v", err)
 		}
 	}
@@ -73,21 +80,25 @@ func key(c *Config) ([]byte, error) {
 func aesEncrypt(c *Config, plaintext string) (string, error) {
 	key, err := key(c)
 	if err != nil {
+		log.Printf("Error retrieving key: %v", err)
 		return "", fmt.Errorf("error retrieving key: %v", err)
 	}
 
 	block, err := aes.NewCipher(key)
 	if err != nil {
+		log.Printf("Error creating cipher block: %v", err)
 		return "", fmt.Errorf("error creating cipher block: %v", err)
 	}
 
 	gcm, err := cipher.NewGCM(block)
 	if err != nil {
-		return "", fmt.Errorf("error creating new gcm: %v", err)
+		log.Printf("Error creating GCM: %v", err)
+		return "", fmt.Errorf("error creating new GCM: %v", err)
 	}
 
 	nonce := make([]byte, gcm.NonceSize())
 	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+		log.Printf("Error creating nonce: %v", err)
 		return "", fmt.Errorf("error creating nonce: %v", err)
 	}
 
@@ -98,30 +109,40 @@ func aesEncrypt(c *Config, plaintext string) (string, error) {
 func aesDecrypt(c *Config, ciphertext string) (string, error) {
 	key, err := key(c)
 	if err != nil {
+		log.Printf("Error retrieving key: %v", err)
 		return "", fmt.Errorf("error retrieving key: %v", err)
 	}
 
 	block, err := aes.NewCipher(key)
 	if err != nil {
+		log.Printf("Error creating cipher block: %v", err)
 		return "", fmt.Errorf("error creating cipher block: %v", err)
 	}
 
 	gcm, err := cipher.NewGCM(block)
 	if err != nil {
-		return "", fmt.Errorf("error creating new gcm: %v", err)
+		log.Printf("Error creating GCM: %v", err)
+		return "", fmt.Errorf("error creating new GCM: %v", err)
 	}
 
 	data, err := base64.StdEncoding.DecodeString(ciphertext)
 	if err != nil {
+		log.Printf("Error base64 decoding ciphertext: %v", err)
 		return "", fmt.Errorf("error base64 decoding ciphertext: %v", err)
 	}
 
 	nonceSize := gcm.NonceSize()
+	if len(data) < nonceSize {
+		errMsg := "ciphertext too short"
+		log.Println(errMsg)
+		return "", fmt.Errorf(errMsg)
+	}
 	nonce, cipherText := data[:nonceSize], data[nonceSize:]
 
 	plaintext, err := gcm.Open(nil, nonce, cipherText, nil)
 	if err != nil {
-		return "", fmt.Errorf("error aes decoding ciphertext: %v", err)
+		log.Printf("Error AES decoding ciphertext: %v", err)
+		return "", fmt.Errorf("error AES decoding ciphertext: %v", err)
 	}
 
 	return string(plaintext), nil
@@ -130,35 +151,41 @@ func aesDecrypt(c *Config, ciphertext string) (string, error) {
 func (db *DB) AddUser(c *Config, u *User, pass string) (int64, error) {
 	hashedPass, err := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost)
 	if err != nil {
+		log.Printf("Error creating password hash: %v", err)
 		return 0, fmt.Errorf("error creating password hash: %v", err)
 	}
 
 	aesFirstName, err := aesEncrypt(c, u.FirstName)
 	if err != nil {
+		log.Printf("Error encrypting first name: %v", err)
 		return 0, fmt.Errorf("error encrypting first name: %v", err)
 	}
 
 	aesLastName, err := aesEncrypt(c, u.LastName)
 	if err != nil {
+		log.Printf("Error encrypting last name: %v", err)
 		return 0, fmt.Errorf("error encrypting last name: %v", err)
 	}
 
 	aesEmail, err := aesEncrypt(c, u.Email)
 	if err != nil {
+		log.Printf("Error encrypting email: %v", err)
 		return 0, fmt.Errorf("error encrypting email: %v", err)
 	}
 
 	query := `
-    INSERT INTO users (username, password, first_name, last_name, email, profile_pic_link, role)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-    `
+        INSERT INTO users (username, password, first_name, last_name, email, profile_pic_link, role)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        `
 
 	result, err := db.Exec(query, u.UserName, string(hashedPass), aesFirstName, aesLastName, aesEmail, u.ProfilePicLink, u.Role)
 	if err != nil {
+		log.Printf("Error inserting new user '%v' into DB: %v", u.UserName, err)
 		return 0, fmt.Errorf("error inserting new user %v into DB: %v", u.UserName, err)
 	}
 	id, err := result.LastInsertId()
 	if err != nil {
+		log.Printf("Error retrieving last insert ID: %v", err)
 		return 0, fmt.Errorf("error inserting user into DB: %v", err)
 	}
 
@@ -169,12 +196,13 @@ func (db *DB) GetID(userName string) int64 {
 	var id int64
 
 	query := `
-    SELECT id
-    FROM users
-    WHERE username = ?
-    `
+        SELECT id
+        FROM users
+        WHERE username = ?
+        `
 	row := db.QueryRow(query, userName)
 	if err := row.Scan(&id); err != nil { // seems like the only possible error is ErrNoRows
+		log.Printf("Error retrieving ID for user '%v': %v", userName, err)
 		return 0
 	}
 
@@ -185,16 +213,18 @@ func (db *DB) CheckPassword(id int64, pass string) error {
 	var queriedPass string
 
 	query := `
-    SELECT password
-    FROM users
-    WHERE id = ?
-    `
+        SELECT password
+        FROM users
+        WHERE id = ?
+        `
 	row := db.QueryRow(query, id)
 	if err := row.Scan(&queriedPass); err != nil {
+		log.Printf("Error reading password from DB for ID '%v': %v", id, err)
 		return fmt.Errorf("error reading password from DB: %v", err)
 	}
 
 	if err := bcrypt.CompareHashAndPassword([]byte(queriedPass), []byte(pass)); err != nil {
+		log.Printf("Incorrect password for ID '%v': %v", id, err)
 		return fmt.Errorf("incorrect password: %v", err)
 	}
 
@@ -204,41 +234,45 @@ func (db *DB) CheckPassword(id int64, pass string) error {
 func (tx *Tx) ChangePassword(id int64, oldPass, newPass string) error {
 	var queriedPass string
 	getQuery := `
-    SELECT password
-    FROM users
-    WHERE id = ?
-    `
+        SELECT password
+        FROM users
+        WHERE id = ?
+        `
 	row := tx.QueryRow(getQuery, id)
 	if err := row.Scan(&queriedPass); err != nil {
+		log.Printf("Error reading password from DB during password change for ID '%v': %v", id, err)
 		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+			log.Fatalf("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 {
+		log.Printf("Incorrect old password for ID '%v': %v", id, err)
 		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+			log.Fatalf("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 {
+		log.Printf("Error creating new password hash for ID '%v': %v", id, err)
 		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+			log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 		}
 		return fmt.Errorf("error creating password hash: %v", err)
 	}
 
 	setQuery := `
-    UPDATE users
-    SET password = ?
-    WHERE id = ?
-    `
+        UPDATE users
+        SET password = ?
+        WHERE id = ?
+        `
 	if _, err = tx.Exec(setQuery, string(newHashedPass), id); err != nil {
+		log.Printf("Error updating password in DB for ID '%v': %v", id, err)
 		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+			log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 		}
 		return fmt.Errorf("error updating password in DB: %v", err)
 	}
@@ -253,28 +287,32 @@ func (db *DB) GetUser(c *Config, id int64) (*User, error) {
 
 	user := new(User)
 	query := `
-    SELECT id, username, first_name, last_name, email, profile_pic_link, role
-    FROM users
-    WHERE id = ?
-    `
+        SELECT id, username, first_name, last_name, email, profile_pic_link, role
+        FROM users
+        WHERE id = ?
+        `
 
 	row := db.QueryRow(query, id)
 	if err := row.Scan(&user.ID, &user.UserName, &aesFirstName, &aesLastName, &aesEmail, &user.ProfilePicLink, &user.Role); err != nil {
+		log.Printf("Error reading user information from DB for ID '%v': %v", id, err)
 		return nil, fmt.Errorf("error reading user information: %v", err)
 	}
 
 	user.FirstName, err = aesDecrypt(c, aesFirstName)
 	if err != nil {
+		log.Printf("Error decrypting first name for ID '%v': %v", id, err)
 		return nil, fmt.Errorf("error decrypting first name: %v", err)
 	}
 
 	user.LastName, err = aesDecrypt(c, aesLastName)
 	if err != nil {
+		log.Printf("Error decrypting last name for ID '%v': %v", id, err)
 		return nil, fmt.Errorf("error decrypting last name: %v", err)
 	}
 
 	user.Email, err = aesDecrypt(c, aesEmail)
 	if err != nil {
+		log.Printf("Error decrypting email for ID '%v': %v", id, err)
 		return nil, fmt.Errorf("error decrypting email: %v", err)
 	}
 
@@ -290,13 +328,15 @@ func (db *DB) UpdateOwnUserAttributes(c *Config, id int64, userName, firstName,
 		err := func() error {
 			tx.Tx, err = db.Begin()
 			if err != nil {
+				log.Printf("Error starting transaction: %v", err)
 				return fmt.Errorf("error starting transaction: %v", err)
 			}
 
 			if !passwordEmpty {
 				if err = tx.ChangePassword(id, oldPass, newPass); err != nil {
+					log.Printf("Error changing password for ID '%v': %v", id, err)
 					if rollbackErr := tx.Rollback(); rollbackErr != nil {
-						log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+						log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 					}
 					return fmt.Errorf("error changing password: %v", err)
 				}
@@ -304,24 +344,27 @@ func (db *DB) UpdateOwnUserAttributes(c *Config, id int64, userName, firstName,
 
 			aesFirstName, err := aesEncrypt(c, firstName)
 			if err != nil {
+				log.Printf("Error encrypting first name for ID '%v': %v", id, err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return fmt.Errorf("error encrypting first name: %v", err)
 			}
 
 			aesLastName, err := aesEncrypt(c, lastName)
 			if err != nil {
+				log.Printf("Error encrypting last name for ID '%v': %v", id, err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return fmt.Errorf("error encrypting last name: %v", err)
 			}
 
 			aesEmail, err := aesEncrypt(c, email)
 			if err != nil {
+				log.Printf("Error encrypting email for ID '%v': %v", id, err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return fmt.Errorf("error encrypting email: %v", err)
 			}
@@ -333,13 +376,15 @@ func (db *DB) UpdateOwnUserAttributes(c *Config, id int64, userName, firstName,
 				&Attribute{Table: "users", ID: id, AttName: "email", Value: aesEmail},
 				&Attribute{Table: "users", ID: id, AttName: "profile_pic_link", Value: profilePicLink},
 			); err != nil {
+				log.Printf("Error updating attributes in DB for ID '%v': %v", id, err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return fmt.Errorf("error updating attributes in DB: %v", err)
 			}
 
 			if err = tx.Commit(); err != nil {
+				log.Printf("Error committing transaction for ID '%v': %v", id, err)
 				return fmt.Errorf("error committing transaction: %v", err)
 			}
 
@@ -353,7 +398,9 @@ func (db *DB) UpdateOwnUserAttributes(c *Config, id int64, userName, firstName,
 		wait(i)
 	}
 
-	return fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
+	errMsg := fmt.Sprintf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
+	log.Println(errMsg)
+	return fmt.Errorf(errMsg)
 }
 
 func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
@@ -361,25 +408,28 @@ func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
 	txOptions := &sql.TxOptions{Isolation: sql.LevelSerializable}
 	selectQuery := "SELECT COUNT(*) FROM users"
 	insertQuery := `
-    INSERT INTO users (username, password, first_name, last_name, email, profile_pic_link, role)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-    `
+        INSERT INTO users (username, password, first_name, last_name, email, profile_pic_link, role)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        `
 
 	for i := 0; i < TxMaxRetries; i++ {
 		id, err := func() (int64, error) {
 			tx, err := db.BeginTx(context.Background(), txOptions)
 			if err != nil {
+				log.Printf("Error starting transaction: %v", err)
 				return 0, fmt.Errorf("error starting transaction: %v", err)
 			}
 
 			if err := tx.QueryRow(selectQuery).Scan(&numUsers); err != nil {
+				log.Printf("Error retrieving number of users: %v", err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return 0, fmt.Errorf("error getting ID of %v: %v", u.UserName, err)
 			}
 			if numUsers != 0 {
 				if err = tx.Commit(); err != nil {
+					log.Printf("Error committing transaction: %v", err)
 					return 0, fmt.Errorf("error committing transaction: %v", err)
 				}
 				return -1, nil
@@ -387,53 +437,60 @@ func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
 
 			hashedPass, err := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost)
 			if err != nil {
+				log.Printf("Error creating password hash: %v", err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return 0, fmt.Errorf("error creating password hash: %v", err)
 			}
 
 			aesFirstName, err := aesEncrypt(c, u.FirstName)
 			if err != nil {
+				log.Printf("Error encrypting first name: %v", err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return 0, fmt.Errorf("error encrypting first name: %v", err)
 			}
 
 			aesLastName, err := aesEncrypt(c, u.LastName)
 			if err != nil {
+				log.Printf("Error encrypting last name: %v", err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return 0, fmt.Errorf("error encrypting last name: %v", err)
 			}
 
 			aesEmail, err := aesEncrypt(c, u.Email)
 			if err != nil {
+				log.Printf("Error encrypting email: %v", err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return 0, fmt.Errorf("error encrypting email: %v", err)
 			}
 
 			result, err := tx.Exec(insertQuery, u.UserName, string(hashedPass), aesFirstName, aesLastName, aesEmail, u.ProfilePicLink, u.Role)
 			if err != nil {
+				log.Printf("Error inserting new user '%v' into DB: %v", u.UserName, err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return 0, fmt.Errorf("error inserting new user %v into DB: %v", u.UserName, err)
 			}
 
 			id, err := result.LastInsertId()
 			if err != nil {
+				log.Printf("Error retrieving last insert ID: %v", err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return 0, fmt.Errorf("error inserting user into DB: %v", err)
 			}
 
 			if err = tx.Commit(); err != nil {
+				log.Printf("Error committing transaction: %v", err)
 				return 0, fmt.Errorf("error committing transaction: %v", err)
 			}
 			return id, nil
@@ -445,7 +502,9 @@ func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
 		log.Println(err)
 		wait(i)
 	}
-	return 0, fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
+	errMsg := fmt.Sprintf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
+	log.Println(errMsg)
+	return 0, fmt.Errorf(errMsg)
 }
 
 func (db *DB) GetAllUsers(c *Config) ([]*User, error) {
@@ -456,34 +515,45 @@ func (db *DB) GetAllUsers(c *Config) ([]*User, error) {
 
 	rows, err := db.Query(query)
 	if err != nil {
+		log.Printf("Error retrieving all users from DB: %v", err)
 		return nil, fmt.Errorf("error getting all users from DB: %v", err)
 	}
+	defer rows.Close()
 
 	users := make([]*User, 0)
 	for rows.Next() {
 		user := new(User)
 		if err = rows.Scan(&user.ID, &user.UserName, &aesFirstName, &aesLastName, &aesEmail, &user.ProfilePicLink, &user.Role); err != nil {
+			log.Printf("Error scanning user information: %v", err)
 			return nil, fmt.Errorf("error getting user info: %v", err)
 		}
 
 		user.FirstName, err = aesDecrypt(c, aesFirstName)
 		if err != nil {
+			log.Printf("Error decrypting first name for user ID '%v': %v", user.ID, err)
 			return nil, fmt.Errorf("error decrypting first name: %v", err)
 		}
 
 		user.LastName, err = aesDecrypt(c, aesLastName)
 		if err != nil {
+			log.Printf("Error decrypting last name for user ID '%v': %v", user.ID, err)
 			return nil, fmt.Errorf("error decrypting last name: %v", err)
 		}
 
 		user.Email, err = aesDecrypt(c, aesEmail)
 		if err != nil {
+			log.Printf("Error decrypting email for user ID '%v': %v", user.ID, err)
 			return nil, fmt.Errorf("error decrypting email: %v", err)
 		}
 
 		users = append(users, user)
 	}
 
+	if err = rows.Err(); err != nil {
+		log.Printf("Error iterating over rows: %v", err)
+		return nil, fmt.Errorf("error iterating over rows: %v", err)
+	}
+
 	return users, nil
 }
 
@@ -495,50 +565,63 @@ func (db *DB) GetAllUsersMap(c *Config) (map[int64]*User, error) {
 
 	rows, err := db.Query(query)
 	if err != nil {
+		log.Printf("Error retrieving all users from DB: %v", err)
 		return nil, fmt.Errorf("error getting all users from DB: %v", err)
 	}
+	defer rows.Close()
 
-	users := make(map[int64]*User, 0)
+	users := make(map[int64]*User)
 	for rows.Next() {
 		user := new(User)
 		if err = rows.Scan(&user.ID, &user.UserName, &aesFirstName, &aesLastName, &aesEmail, &user.ProfilePicLink, &user.Role); err != nil {
+			log.Printf("Error scanning user information: %v", err)
 			return nil, fmt.Errorf("error getting user info: %v", err)
 		}
 
 		user.FirstName, err = aesDecrypt(c, aesFirstName)
 		if err != nil {
+			log.Printf("Error decrypting first name for user ID '%v': %v", user.ID, err)
 			return nil, fmt.Errorf("error decrypting first name: %v", err)
 		}
 
 		user.LastName, err = aesDecrypt(c, aesLastName)
 		if err != nil {
+			log.Printf("Error decrypting last name for user ID '%v': %v", user.ID, err)
 			return nil, fmt.Errorf("error decrypting last name: %v", err)
 		}
 
 		user.Email, err = aesDecrypt(c, aesEmail)
 		if err != nil {
+			log.Printf("Error decrypting email for user ID '%v': %v", user.ID, err)
 			return nil, fmt.Errorf("error decrypting email: %v", err)
 		}
 
 		users[user.ID] = user
 	}
 
+	if err = rows.Err(); err != nil {
+		log.Printf("Error iterating over rows: %v", err)
+		return nil, fmt.Errorf("error iterating over rows: %v", err)
+	}
+
 	return users, nil
 }
 
 func (tx *Tx) SetPassword(id int64, newPass string) error {
 	hashedPass, err := bcrypt.GenerateFromPassword([]byte(newPass), bcrypt.DefaultCost)
 	if err != nil {
+		log.Printf("Error creating password hash for ID '%v': %v", id, err)
 		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+			log.Fatalf("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(hashedPass), id); err != nil {
+		log.Printf("Error updating password in DB for ID '%v': %v", id, err)
 		if rollbackErr := tx.Rollback(); rollbackErr != nil {
-			log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+			log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 		}
 		return fmt.Errorf("error updating password in DB: %v", err)
 	}
@@ -555,13 +638,15 @@ func (db *DB) UpdateUserAttributes(c *Config, id int64, userName, firstName, las
 		err := func() error {
 			tx.Tx, err = db.Begin()
 			if err != nil {
+				log.Printf("Error starting transaction: %v", err)
 				return fmt.Errorf("error starting transaction: %v", err)
 			}
 
 			if !passwordEmpty {
 				if err = tx.SetPassword(id, newPass); err != nil {
+					log.Printf("Error setting new password for ID '%v': %v", id, err)
 					if rollbackErr := tx.Rollback(); rollbackErr != nil {
-						log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+						log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 					}
 					return fmt.Errorf("error changing password: %v", err)
 				}
@@ -569,24 +654,27 @@ func (db *DB) UpdateUserAttributes(c *Config, id int64, userName, firstName, las
 
 			aesFirstName, err := aesEncrypt(c, firstName)
 			if err != nil {
+				log.Printf("Error encrypting first name for ID '%v': %v", id, err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return fmt.Errorf("error encrypting first name: %v", err)
 			}
 
 			aesLastName, err := aesEncrypt(c, lastName)
 			if err != nil {
+				log.Printf("Error encrypting last name for ID '%v': %v", id, err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return fmt.Errorf("error encrypting last name: %v", err)
 			}
 
 			aesEmail, err := aesEncrypt(c, email)
 			if err != nil {
+				log.Printf("Error encrypting email for ID '%v': %v", id, err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return fmt.Errorf("error encrypting email: %v", err)
 			}
@@ -599,13 +687,15 @@ func (db *DB) UpdateUserAttributes(c *Config, id int64, userName, firstName, las
 				&Attribute{Table: "users", ID: id, AttName: "profile_pic_link", Value: profilePicLink},
 				&Attribute{Table: "users", ID: id, AttName: "role", Value: role},
 			); err != nil {
+				log.Printf("Error updating attributes in DB for ID '%v': %v", id, err)
 				if rollbackErr := tx.Rollback(); rollbackErr != nil {
-					log.Fatalf("transaction error: %v, rollback error: %v", err, rollbackErr)
+					log.Fatalf("Transaction error: %v, Rollback error: %v", err, rollbackErr)
 				}
 				return fmt.Errorf("error updating attributes in DB: %v", err)
 			}
 
 			if err = tx.Commit(); err != nil {
+				log.Printf("Error committing transaction for ID '%v': %v", id, err)
 				return fmt.Errorf("error committing transaction: %v", err)
 			}
 
@@ -619,7 +709,9 @@ func (db *DB) UpdateUserAttributes(c *Config, id int64, userName, firstName, las
 		wait(i)
 	}
 
-	return fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
+	errMsg := fmt.Sprintf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
+	log.Println(errMsg)
+	return fmt.Errorf(errMsg)
 }
 
 func (db *DB) DeleteUser(id int64) error {
@@ -627,6 +719,7 @@ func (db *DB) DeleteUser(id int64) error {
 
 	_, err := db.Exec(query, id)
 	if err != nil {
+		log.Printf("Error deleting user with ID '%v' from DB: %v", id, err)
 		return fmt.Errorf("error deleting user %v from DB: %v", id, err)
 	}
 

cmd/calls/articles.go

@@ -5,8 +5,8 @@ import (
 	"log"
 	"net/http"
 	"os"
-	"strconv"
 
+	"github.com/google/uuid"
 	b "streifling.com/jason/cpolis/cmd/backend"
 )
 
@@ -37,15 +37,15 @@ func ServeArticle(c *b.Config, db *b.DB) http.HandlerFunc {
 			return
 		}
 
-		idString := r.PathValue("id")
-		id, err := strconv.ParseInt(idString, 10, 64)
+		uuidString := r.PathValue("uuid")
+		uuid, err := uuid.Parse(uuidString)
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 
-		article, err := db.GetArticle(id)
+		article, err := db.GetArticleByUUID(uuid)
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -56,7 +56,7 @@ func ServeArticle(c *b.Config, db *b.DB) http.HandlerFunc {
 			return
 		}
 
-		articleAbsName := fmt.Sprint(c.ArticleDir, "/", article.ID, ".md")
+		articleAbsName := fmt.Sprint(c.ArticleDir, "/", article.UUID, ".md")
 		contentBytes, err := os.ReadFile(articleAbsName)
 		if err != nil {
 			log.Println(err)
@@ -87,15 +87,14 @@ func ServeArticle(c *b.Config, db *b.DB) http.HandlerFunc {
 
 func ServeClicks(db *b.DB) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		idString := r.PathValue("id")
-		id, err := strconv.ParseInt(idString, 10, 64)
+		uuid, err := uuid.Parse(r.PathValue("uuid"))
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 
-		article, err := db.GetArticle(id)
+		article, err := db.GetArticleByUUID(uuid)
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)

cmd/calls/atom.go

@@ -1,9 +1,7 @@
 package calls
 
 import (
-	"log"
 	"net/http"
-	"path/filepath"
 
 	b "streifling.com/jason/cpolis/cmd/backend"
 )
@@ -14,13 +12,6 @@ func ServeAtomFeed(c *b.Config) http.HandlerFunc {
 			return
 		}
 
-		absFilepath, err := filepath.Abs(c.AtomFile)
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		http.ServeFile(w, r, absFilepath)
+		http.ServeFile(w, r, c.AtomFile)
 	}
 }

cmd/calls/images.go

@@ -1,7 +1,6 @@
 package calls
 
 import (
-	"log"
 	"net/http"
 	"path/filepath"
 
@@ -17,13 +16,6 @@ func ServeImage(c *b.Config, s map[string]*f.Session) http.HandlerFunc {
 			}
 		}
 
-		absFilepath, err := filepath.Abs(c.PicsDir)
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		http.ServeFile(w, r, absFilepath+"/"+r.PathValue("pic"))
+		http.ServeFile(w, r, filepath.Join(c.PicsDir, r.PathValue("pic")))
 	}
 }

cmd/frontend/articles.go

@@ -6,6 +6,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
@@ -83,7 +84,7 @@ func WriteArticle(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc
 			return
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/editor.html")
+		tmpl, err := template.ParseFiles(filepath.Join(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)
@@ -205,7 +206,7 @@ func SubmitArticle(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFun
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -340,7 +341,7 @@ func ResubmitArticle(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerF
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -384,7 +385,7 @@ func ShowUnpublishedUnrejectedAndPublishedRejectedArticles(c *b.Config, db *b.DB
 			}
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/unpublished-articles.html")
+		tmpl, err := template.ParseFiles(filepath.Join(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)
@@ -420,7 +421,7 @@ func ShowRejectedArticles(c *b.Config, db *b.DB, s map[string]*Session) http.Han
 			}
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/rejected-articles.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "rejected-articles.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -524,7 +525,7 @@ func ReviewRejectedArticle(c *b.Config, db *b.DB, s map[string]*Session) http.Ha
 
 		data.Action = fmt.Sprint("resubmit/", data.Article.ID)
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/editor.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "editor.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -614,7 +615,7 @@ func PublishArticle(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFu
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -648,7 +649,7 @@ func RejectArticle(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFun
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -672,7 +673,7 @@ func ShowCurrentIssue(c *b.Config, db *b.DB, s map[string]*Session) http.Handler
 			return
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/current-issue.html")
+		tmpl, err := template.ParseFiles(filepath.Join(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)
@@ -707,7 +708,7 @@ func ShowPublishedArticles(c *b.Config, db *b.DB, s map[string]*Session, action
 			}
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/published-articles.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "published-articles.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -802,7 +803,7 @@ func ReviewArticle(c *b.Config, db *b.DB, s map[string]*Session, action, title,
 			return
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/review-article.html")
+		tmpl, err := template.ParseFiles(filepath.Join(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)
@@ -845,6 +846,13 @@ func DeleteArticle(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFun
 			return
 		}
 
+		go func(c *b.Config, db *b.DB) {
+			if err = b.CleanUpImages(c, db); err != nil {
+				log.Println(err)
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+			}
+		}(c, db)
+
 		feed, err := b.GenerateAtomFeed(c, db)
 		if err != nil {
 			log.Println(err)
@@ -860,7 +868,7 @@ func DeleteArticle(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFun
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -953,7 +961,7 @@ func AllowEditArticle(c *b.Config, db *b.DB, s map[string]*Session) http.Handler
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl := template.Must(template.ParseFiles(c.WebDir + "/templates/hub.html"))
+		tmpl := template.Must(template.ParseFiles(filepath.Join(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)
@@ -1015,7 +1023,7 @@ func EditArticle(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc
 
 		data.Action = fmt.Sprint("save/", data.Article.ID)
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/editor.html")
+		tmpl, err := template.ParseFiles(filepath.Join(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)

cmd/frontend/docx.go

@@ -44,22 +44,15 @@ func UploadDocx(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 			return
 		}
 
-		docxFilename := fmt.Sprint(uuid.New(), ".docx")
-		absDocxFilepath, err := filepath.Abs("/tmp/" + docxFilename)
-		if err != nil {
+		docxFilepath := filepath.Join(os.TempDir(), fmt.Sprint(uuid.New(), ".docx"))
+		if err = os.WriteFile(docxFilepath, buf.Bytes(), 0644); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
+		defer os.Remove(docxFilepath)
 
-		if err = os.WriteFile(absDocxFilepath, buf.Bytes(), 0644); err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		defer os.Remove(absDocxFilepath)
-
-		mdString, err := b.ConvertToMarkdown(c, absDocxFilepath)
+		mdString, err := b.ConvertToMarkdown(c, docxFilepath)
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -67,15 +60,8 @@ func UploadDocx(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 		}
 
 		uuidName := uuid.New()
-		mdFilename := fmt.Sprint(uuidName, ".md")
-		absMdFilepath, err := filepath.Abs(c.ArticleDir + "/" + mdFilename)
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		if err = os.WriteFile(absMdFilepath, mdString, 0644); err != nil {
+		mdFilepath := filepath.Join(c.ArticleDir, fmt.Sprint(uuidName, ".md"))
+		if err = os.WriteFile(mdFilepath, mdString, 0644); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return

cmd/frontend/homepage.go

@@ -4,6 +4,7 @@ import (
 	"html/template"
 	"log"
 	"net/http"
+	"path/filepath"
 	"time"
 
 	b "streifling.com/jason/cpolis/cmd/backend"
@@ -24,14 +25,14 @@ func HomePage(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 		data.Version = c.Version
 
 		files := make([]string, 2)
-		files[0] = c.WebDir + "/templates/index.html"
+		files[0] = filepath.Join(c.WebDir, "templates", "index.html")
 		if numRows == 0 {
 			data.Role = b.NonExistent
 			data.Title = "Erster Benutzer (Administrator)"
 			data.ButtonText = "Anlegen"
 			data.URL = "/user/add-first"
 
-			files[1] = c.WebDir + "/templates/edit-user.html"
+			files[1] = filepath.Join(c.WebDir, "templates", "edit-user.html")
 			tmpl, err := template.ParseFiles(files...)
 			if err = template.Must(tmpl, err).Execute(w, data); err != nil {
 				log.Println(err)
@@ -41,7 +42,7 @@ func HomePage(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 		} else {
 			cookie, err := r.Cookie("cpolis_session")
 			if err != nil {
-				files[1] = c.WebDir + "/templates/login.html"
+				files[1] = filepath.Join(c.WebDir, "templates", "login.html")
 				tmpl, err := template.ParseFiles(files...)
 				if err = template.Must(tmpl, err).Execute(w, data); err != nil {
 					log.Println(err)
@@ -56,7 +57,7 @@ func HomePage(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 				cookie.Expires = time.Now()
 				http.SetCookie(w, cookie)
 
-				files[1] = c.WebDir + "/templates/login.html"
+				files[1] = filepath.Join(c.WebDir, "templates", "login.html")
 				tmpl, err := template.ParseFiles(files...)
 				if err = template.Must(tmpl, err).Execute(w, data); err != nil {
 					log.Println(err)
@@ -67,7 +68,7 @@ func HomePage(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 			}
 
 			data.Role = session.User.Role
-			files[1] = c.WebDir + "/templates/hub.html"
+			files[1] = filepath.Join(c.WebDir, "templates", "hub.html")
 			tmpl, err := template.ParseFiles(files...)
 			if err = template.Must(tmpl, err).Execute(w, data); err != nil {
 				log.Println(err)
@@ -89,7 +90,7 @@ func ShowHub(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)

cmd/frontend/images.go

@@ -5,6 +5,7 @@ import (
 	"html/template"
 	"log"
 	"net/http"
+	"path/filepath"
 
 	b "streifling.com/jason/cpolis/cmd/backend"
 )
@@ -70,7 +71,7 @@ func UploadImage(c *b.Config, s map[string]*Session, fileKey, htmlFile, htmlTemp
 		data := new(struct{ Image string })
 		data.Image = filename
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/" + htmlFile)
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", htmlFile))
 		if err = template.Must(tmpl, err).ExecuteTemplate(w, htmlTemplate, data); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)

cmd/frontend/issues.go

@@ -6,6 +6,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"path/filepath"
 	"time"
 
 	"github.com/google/uuid"
@@ -91,7 +92,7 @@ func PublishLatestIssue(c *b.Config, db *b.DB, s map[string]*Session) http.Handl
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)

cmd/frontend/pdf.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"net/http"
 	"path/filepath"
+	"strings"
 
 	"github.com/google/uuid"
 	b "streifling.com/jason/cpolis/cmd/backend"
@@ -17,7 +18,7 @@ func UploadPDF(c *b.Config, s map[string]*Session) http.HandlerFunc {
 			return
 		}
 
-		file, _, err := r.FormFile("pdf-upload")
+		file, header, err := r.FormFile("pdf-upload")
 		if err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -43,15 +44,11 @@ func UploadPDF(c *b.Config, s map[string]*Session) http.HandlerFunc {
 			return
 		}
 
-		filename := fmt.Sprint(uuid.New(), ".pdf")
-		absFilepath, err := filepath.Abs(c.PDFDir + "/" + filename)
-		if err != nil {
-			log.Println(err)
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
+		oldFilename := strings.Join(strings.Split(header.Filename, ".")[:len(header.Filename)-1], ".")
+		filename := fmt.Sprint(oldFilename, ".", uuid.New(), ".pdf")
+		filepath := filepath.Join(c.PDFDir, filename)
 
-		if err = b.WriteFile(absFilepath, file); err != nil {
+		if err = b.WriteFile(filepath, file); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return

cmd/frontend/sessions.go

@@ -7,6 +7,7 @@ import (
 	"html/template"
 	"log"
 	"net/http"
+	"path/filepath"
 	"time"
 
 	"github.com/google/uuid"
@@ -67,7 +68,7 @@ func StartSessions() (map[string]*Session, chan string) {
 // their session and an error. It also handles cases where the user is not
 // logged in.
 func ManageSession(w http.ResponseWriter, r *http.Request, c *b.Config, s map[string]*Session) (*Session, error) {
-	tmpl, tmplErr := template.ParseFiles(c.WebDir+"/templates/index.html", c.WebDir+"/templates/login.html")
+	tmpl, tmplErr := template.ParseFiles(filepath.Join(c.WebDir, "templates", "index.html"), filepath.Join(c.WebDir, "templates", "login.html"))
 
 	cookie, err := r.Cookie("cpolis_session")
 	if err != nil {
@@ -124,7 +125,7 @@ func Login(c *b.Config, db *b.DB, s map[string]*Session, sessionExpiryChan chan
 		s[session.cookie.Value] = session
 		http.SetCookie(w, session.cookie)
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", user); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -135,7 +136,7 @@ func Login(c *b.Config, db *b.DB, s map[string]*Session, sessionExpiryChan chan
 
 func Logout(c *b.Config, s map[string]*Session) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		tmpl, tmplErr := template.ParseFiles(c.WebDir + "/templates/login.html")
+		tmpl, tmplErr := template.ParseFiles(filepath.Join(c.WebDir, "templates", "login.html"))
 
 		cookie, err := r.Cookie("cpolis_session")
 		if err != nil {

cmd/frontend/tags.go

@@ -4,6 +4,7 @@ import (
 	"html/template"
 	"log"
 	"net/http"
+	"path/filepath"
 
 	b "streifling.com/jason/cpolis/cmd/backend"
 )
@@ -15,7 +16,7 @@ func CreateTag(c *b.Config, s map[string]*Session) http.HandlerFunc {
 			return
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/add-tag.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "add-tag.html"))
 		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", nil); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -42,7 +43,7 @@ func AddTag(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)

cmd/frontend/users.go

@@ -5,6 +5,7 @@ import (
 	"html/template"
 	"log"
 	"net/http"
+	"path/filepath"
 	"sort"
 	"strconv"
 
@@ -57,7 +58,7 @@ func CreateUser(c *b.Config, s map[string]*Session) http.HandlerFunc {
 			URL:        "/user/add",
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/edit-user.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "edit-user.html"))
 		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -134,7 +135,7 @@ func AddUser(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -167,7 +168,7 @@ func EditSelf(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 			Image:      user.ProfilePicLink,
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/edit-user.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "edit-user.html"))
 		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -242,7 +243,7 @@ func UpdateSelf(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
@@ -312,7 +313,7 @@ func AddFirstUser(c *b.Config, db *b.DB, s map[string]*Session, sessionExpiryCha
 		data := new(struct{ Role int })
 		data.Role = user.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -343,7 +344,7 @@ func ShowAllUsers(c *b.Config, db *b.DB, s map[string]*Session, action string) h
 		}
 		delete(data.Users, session.User.ID)
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/show-all-users.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "show-all-users.html"))
 		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -381,7 +382,7 @@ func EditUser(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 			Image:      user.ProfilePicLink,
 		}
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/edit-user.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "edit-user.html"))
 		if err = template.Must(tmpl, err).ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -466,7 +467,7 @@ func UpdateUser(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl := template.Must(template.ParseFiles(c.WebDir + "/templates/hub.html"))
+		tmpl := template.Must(template.ParseFiles(filepath.Join(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)
@@ -499,7 +500,7 @@ func DeleteUser(c *b.Config, db *b.DB, s map[string]*Session) http.HandlerFunc {
 		data := new(struct{ Role int })
 		data.Role = session.User.Role
 
-		tmpl, err := template.ParseFiles(c.WebDir + "/templates/hub.html")
+		tmpl, err := template.ParseFiles(filepath.Join(c.WebDir, "templates", "hub.html"))
 		tmpl = template.Must(tmpl, err)
 		if err = tmpl.ExecuteTemplate(w, "page-content", data); err != nil {
 			log.Println(err)

cmd/main.go

@@ -4,6 +4,7 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"time"
 
 	b "streifling.com/jason/cpolis/cmd/backend"
 	c "streifling.com/jason/cpolis/cmd/calls"
@@ -32,7 +33,14 @@ func main() {
 	sessions, sessionExpiryChan := f.StartSessions()
 	defer close(sessionExpiryChan)
 
-	// go b.CleanUpImages(config)
+	go func(c *b.Config, db *b.DB) {
+		for {
+			if err = b.CleanUpImages(c, db); err != nil {
+				log.Println(err)
+			}
+			time.Sleep(time.Hour * 24)
+		}
+	}(config, db)
 
 	mux := http.NewServeMux()
 	mux.Handle("/web/static/", http.StripPrefix("/web/static/",
@@ -52,8 +60,8 @@ func main() {
 	mux.HandleFunc("GET /article/review-edit/{id}", f.ReviewArticle(config, db, sessions, "allow-edit", "Artikel bearbeiten", "Bearbeiten erlauben"))
 	mux.HandleFunc("GET /article/review-rejected/{id}", f.ReviewRejectedArticle(config, db, sessions))
 	mux.HandleFunc("GET /article/review-unpublished/{id}", f.ReviewArticle(config, db, sessions, "publish", "Artikel veröffentlichen", "Veröffentlichen"))
-	mux.HandleFunc("GET /article/serve/{id}", c.ServeArticle(config, db))
-	mux.HandleFunc("GET /article/serve/{id}/clicks", c.ServeClicks(db))
+	mux.HandleFunc("GET /article/serve/{uuid}", c.ServeArticle(config, db))
+	mux.HandleFunc("GET /article/serve/{uuid}/clicks", c.ServeClicks(db))
 	mux.HandleFunc("GET /article/write", f.WriteArticle(config, db, sessions))
 	mux.HandleFunc("GET /atom/serve", c.ServeAtomFeed(config))
 	mux.HandleFunc("GET /hub", f.ShowHub(config, db, sessions))

web/templates/index.html

@@ -38,11 +38,11 @@
     </main>
 
     <footer class="text-center text-gray-500 my-8">
-        <p>&copy; 2024 Jason Streifling. Alle Rechte vorbehalten.</p>
+        <p>&copy; 2025 Jason Streifling. Alle Rechte vorbehalten.</p>
         <p>{{.Version}} - <strong>Alpha: Drastische Änderungen und Fehler vorbehalten.</strong></p>
     </footer>
 
-    <script src="https://unpkg.com/htmx.org@2.0.3"></script>
+    <script src="https://unpkg.com/htmx.org@latest"></script>
     <script src="https://unpkg.com/easymde/dist/easymde.min.js"></script>
     <script>
         document.addEventListener('DOMContentLoaded', () => {