use commonmark

cmd/backend/atom.go

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

cmd/backend/docx.go

@@ -21,7 +21,7 @@ func ConvertToMarkdown(c *Config, filename string) ([]byte, error) {
 	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 := exec.Command("pandoc", "-s", "-f", "docx", "-t", "commonmark", "-o", articleFileName, "--extract-media", tmpDir, filename) // TODO: Is writing to a file necessary?
 	cmd.Stderr = &stderr
 	if err = cmd.Run(); err != nil {
 		return nil, fmt.Errorf("error converting docx to markdown: %v: %v", err, stderr.String())

cmd/backend/users.go

@@ -37,19 +37,15 @@ type User struct {
 func readKey(filename string) ([]byte, error) {
 	key, err := os.ReadFile(filename)
 	if err != nil {
-		log.Printf("Error reading AES key file '%s': %v", filename, err)
-		return nil, fmt.Errorf("error reading from AES key file: %v", err)
+		return nil, fmt.Errorf("error reading from aes key file: %v", err)
 	}
 
 	if len(key) != 44 {
-		errMsg := "key is not 32 bytes long"
-		log.Println(errMsg)
-		return nil, errors.New(errMsg)
+		return nil, errors.New("key is not 32 bytes long")
 	}
 
 	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)
 	}
 
@@ -59,17 +55,14 @@ 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)
 		}
 	}
@@ -80,25 +73,21 @@ 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 {
-		log.Printf("Error creating GCM: %v", err)
-		return "", fmt.Errorf("error creating new 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)
 	}
 
@@ -109,40 +98,30 @@ 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 {
-		log.Printf("Error creating GCM: %v", err)
-		return "", fmt.Errorf("error creating new 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 {
-		log.Printf("Error AES decoding ciphertext: %v", err)
-		return "", fmt.Errorf("error AES decoding ciphertext: %v", err)
+		return "", fmt.Errorf("error aes decoding ciphertext: %v", err)
 	}
 
 	return string(plaintext), nil
@@ -151,41 +130,35 @@ 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)
 	}
 
@@ -196,13 +169,12 @@ 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
 	}
 
@@ -213,18 +185,16 @@ 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)
 	}
 
@@ -234,45 +204,41 @@ 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)
 	}
@@ -287,32 +253,28 @@ 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)
 	}
 
@@ -328,15 +290,13 @@ 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)
 				}
@@ -344,27 +304,24 @@ 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)
 			}
@@ -376,15 +333,13 @@ 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)
 			}
 
@@ -398,9 +353,7 @@ func (db *DB) UpdateOwnUserAttributes(c *Config, id int64, userName, firstName,
 		wait(i)
 	}
 
-	errMsg := fmt.Sprintf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
-	log.Println(errMsg)
-	return fmt.Errorf(errMsg)
+	return fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
 }
 
 func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
@@ -408,28 +361,25 @@ 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
@@ -437,60 +387,53 @@ 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
@@ -502,9 +445,7 @@ func (db *DB) AddFirstUser(c *Config, u *User, pass string) (int64, error) {
 		log.Println(err)
 		wait(i)
 	}
-	errMsg := fmt.Sprintf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
-	log.Println(errMsg)
-	return 0, fmt.Errorf(errMsg)
+	return 0, fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
 }
 
 func (db *DB) GetAllUsers(c *Config) ([]*User, error) {
@@ -515,45 +456,34 @@ 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
 }
 
@@ -565,63 +495,50 @@ 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)
+	users := make(map[int64]*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[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)
 	}
@@ -638,15 +555,13 @@ 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)
 				}
@@ -654,27 +569,24 @@ 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)
 			}
@@ -687,15 +599,13 @@ 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)
 			}
 
@@ -709,9 +619,7 @@ func (db *DB) UpdateUserAttributes(c *Config, id int64, userName, firstName, las
 		wait(i)
 	}
 
-	errMsg := fmt.Sprintf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
-	log.Println(errMsg)
-	return fmt.Errorf(errMsg)
+	return fmt.Errorf("error: %v unsuccessful retries for DB operation, aborting", TxMaxRetries)
 }
 
 func (db *DB) DeleteUser(id int64) error {
@@ -719,7 +627,6 @@ 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)
 	}