feat: article attachments with content-addressed dedup

Add an attachments table and AJAX upload/management on the article create and edit pages. - Attachment model with article_id (0 while pending on create), session_token ownership, and SHA-256 content-addressed stored_name - Upload validates via the platform policy (switch/type/size) and deduplicates on disk by content hash - Plan-A binding: attachments uploaded before an article exists are owned by a session token and bound to the new article on save - Delete soft-removes the record and drops the disk file only when no remaining rows reference it (reference counting for deduped files) - Edit page loads existing attachments via JSON list endpoint - Row actions: insert into body (markdown image/link), set as cover (image only), and delete - Download URLs use the configured default download base URL when set, else the local /uploads path Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-06-21 21:02:09 +08:00
parent 0c5bcde7da
commit e872c08f3b
7 changed files with 486 additions and 13 deletions
@@ -1,6 +1,8 @@
 package handlers

 import (
+	"crypto/rand"
+	"encoding/hex"
 	"net/http"
 	"regexp"
 	"strconv"
@@ -17,6 +19,17 @@ import (
 // slugRe matches characters that are not URL-safe.
 var slugRe = regexp.MustCompile(`[^a-z0-9\-]+`)

+// randomToken returns a 32-byte hex token used to own pending attachments on
+// the article-create page until the article is saved.
+func randomToken() string {
+	b := make([]byte, 32)
+	if _, err := rand.Read(b); err != nil {
+		// Extremely unlikely; fall back to a time-based value.
+		return strconv.FormatInt(time.Now().UnixNano(), 16)
+	}
+	return hex.EncodeToString(b)
+}
+
 // generateSlug converts a title into a URL-friendly slug.
 func generateSlug(title string) string {
 	s := strings.ToLower(title)
@@ -31,15 +44,17 @@ func generateSlug(title string) string {
 // articleForm holds the parsed article form fields, shared by the create and
 // edit handlers and their validation-error repopulation paths.
 type articleForm struct {
-	Title      string
-	Slug       string
-	Summary    string
-	Content    string
-	Cover      string
-	StatusStr  string
-	IsTop      bool
-	Action     string // form action URL
-	TitleText  string // page heading text (create vs edit)
+	Title        string
+	Slug         string
+	Summary      string
+	Content      string
+	Cover        string
+	StatusStr    string
+	IsTop        bool
+	Action       string // form action URL
+	TitleText    string // page heading text (create vs edit)
+	ArticleID    uint   // existing article ID (edit page); 0 on create
+	SessionToken string // pending-attachment ownership token (create page)
 }

 // parseArticleForm reads and trims the article form fields from the request.
@@ -67,6 +82,8 @@ func applyFormToData(data gin.H, f articleForm) {
 	data["FormIsTop"] = f.IsTop
 	data["FormAction"] = f.Action
 	data["FormTitleText"] = f.TitleText
+	data["FormArticleID"] = f.ArticleID
+	data["SessionToken"] = f.SessionToken
 }

 // renderArticleForm renders the shared article form template with the given
@@ -117,9 +134,10 @@ func ArticleCreatePage(db *gorm.DB) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		tr := getTr(c)
 		renderArticleForm(c, db, articleForm{
-			Action:    "/admin/articles/new",
-			TitleText: tr["article_create_title"],
-			StatusStr: "0",
+			Action:       "/admin/articles/new",
+			TitleText:    tr["article_create_title"],
+			StatusStr:    "0",
+			SessionToken: randomToken(),
 		}, "")
 	}
 }
@@ -131,6 +149,7 @@ func ArticleCreate(db *gorm.DB) gin.HandlerFunc {
 		f := parseArticleForm(c)
 		f.Action = "/admin/articles/new"
 		f.TitleText = tr["article_create_title"]
+		f.SessionToken = strings.TrimSpace(c.PostForm("session_token"))

 		// Validate required fields.
 		if f.Title == "" {
@@ -178,6 +197,12 @@ func ArticleCreate(db *gorm.DB) gin.HandlerFunc {
 			return
 		}

+		// Bind any attachments uploaded during creation (plan A: pending rows
+		// owned by session_token, article_id=0).
+		if f.SessionToken != "" {
+			_ = BindPendingAttachments(db, f.SessionToken, article.ID)
+		}
+
 		// Success: redirect to dashboard.
 		c.Redirect(http.StatusFound, "/admin")
 	}
@@ -218,6 +243,7 @@ func ArticleEditPage(db *gorm.DB) gin.HandlerFunc {
 			IsTop:     article.IsTop,
 			Action:    "/admin/articles/" + id + "/edit",
 			TitleText: tr["article_edit_title"],
+			ArticleID: article.ID,
 		}, "")
 	}
 }
@@ -0,0 +1,232 @@
+package handlers
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+
+	"go_blog/models"
+)
+
+// attachmentsDir returns the on-disk directory for attachments under the given
+// storage path, honoring the configured storage_dir.
+func attachmentsDir(storagePath string) string {
+	dir := models.GetUploadConfig().StorageDir
+	if dir == "" {
+		dir = "attachments"
+	}
+	return filepath.Join(storagePath, dir)
+}
+
+// attachmentRelPath returns the path of an attachment relative to the storage
+// root, e.g. "attachments/<stored>" — used to build /uploads URLs.
+func attachmentRelPath(stored string) string {
+	dir := models.GetUploadConfig().StorageDir
+	if dir == "" {
+		dir = "attachments"
+	}
+	return dir + "/" + stored
+}
+
+// attachmentURL builds the public URL for an attachment: the default download
+// base URL (if configured) joined with the relative path, else the local
+// /uploads path served by the app.
+func attachmentURL(stored string) string {
+	rel := attachmentRelPath(stored)
+	if base := models.DefaultDownloadBaseURL(); base != "" {
+		return strings.TrimRight(base, "/") + "/" + rel
+	}
+	return "/uploads/" + rel
+}
+
+// ---------------- Upload ----------------
+
+// UploadAttachment handles AJAX attachment uploads from the article create/edit
+// form. The request carries either a real article_id (edit page) or a
+// session_token (create page, pending binding). Files are content-addressed by
+// SHA-256 for on-disk deduplication.
+func UploadAttachment(db *gorm.DB, storagePath string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		uploaderID, ok := sessionAuthorID(c)
+		if !ok {
+			c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized"})
+			return
+		}
+
+		articleID := parseUintForm(c, "article_id")
+		token := strings.TrimSpace(c.PostForm("session_token"))
+		// On the create page the article does not exist yet; require a token.
+		if articleID == 0 && token == "" {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "missing session_token"})
+			return
+		}
+
+		file, header, err := c.Request.FormFile("file")
+		if err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": "no file provided"})
+			return
+		}
+		defer file.Close()
+
+		// Validate against the platform upload policy (switch + type + size).
+		check := ValidateUpload(header)
+		if !check.OK {
+			if !models.GetUploadConfig().Enabled {
+				c.JSON(http.StatusForbidden, gin.H{"error": "uploads are disabled"})
+				return
+			}
+			if check.Type != nil {
+				c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("file too large; limit is %s", formatSize(check.MaxSize))})
+				return
+			}
+			c.JSON(http.StatusBadRequest, gin.H{"error": "file type not allowed"})
+			return
+		}
+
+		// Read fully to compute the content hash.
+		content, err := io.ReadAll(file)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to read file"})
+			return
+		}
+		sum := sha256.Sum256(content)
+		stored := hex.EncodeToString(sum[:])
+
+		// Deduplicate on disk: only write when the file is absent.
+		dir := attachmentsDir(storagePath)
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to create storage dir"})
+			return
+		}
+		dstPath := filepath.Join(dir, stored)
+		if _, err := os.Stat(dstPath); os.IsNotExist(err) {
+			if err := os.WriteFile(dstPath, content, 0644); err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to save file"})
+				return
+			}
+		}
+
+		ext := strings.ToLower(filepath.Ext(header.Filename))
+		att := models.Attachment{
+			ArticleID:    articleID,
+			SessionToken: token,
+			UploaderID:   uploaderID,
+			Filename:     header.Filename,
+			StoredName:   stored,
+			Ext:          ext,
+			MIME:         header.Header.Get("Content-Type"),
+			Size:         header.Size,
+			Category:     check.Type.Category,
+		}
+		if err := db.Create(&att).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to record attachment"})
+			return
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"id":       att.ID,
+			"filename": att.Filename,
+			"size":     att.Size,
+			"category": att.Category,
+			"url":      attachmentURL(att.StoredName),
+			"is_image": att.IsImage(),
+		})
+	}
+}
+
+// ---------------- Delete ----------------
+
+// DeleteAttachment soft-deletes an attachment record and removes the on-disk
+// file only when no remaining records reference it (reference counting, since
+// content-addressed files may be shared).
+func DeleteAttachment(db *gorm.DB, storagePath string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		id := parseUintParam(c, "id")
+		var att models.Attachment
+		if err := db.First(&att, id).Error; err != nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "not found"})
+			return
+		}
+		stored := att.StoredName
+
+		if err := db.Delete(&att).Error; err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete"})
+			return
+		}
+
+		// Reference count: any other (non-deleted) rows pointing at this file?
+		var count int64
+		db.Model(&models.Attachment{}).Where("stored_name = ?", stored).Count(&count)
+		if count == 0 {
+			os.Remove(filepath.Join(attachmentsDir(storagePath), stored)) // ignore error
+		}
+		c.JSON(http.StatusOK, gin.H{"ok": true})
+	}
+}
+
+// ---------------- List ----------------
+
+// ListAttachments returns the attachments for an article as JSON (used by the
+// edit page to repopulate the list on load).
+func ListAttachments(db *gorm.DB) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		articleID := parseUintParam(c, "id")
+		var atts []models.Attachment
+		db.Where("article_id = ?", articleID).Order("created_at ASC").Find(&atts)
+
+		out := make([]gin.H, 0, len(atts))
+		for _, a := range atts {
+			out = append(out, gin.H{
+				"id":       a.ID,
+				"filename": a.Filename,
+				"size":     a.Size,
+				"category": a.Category,
+				"url":      attachmentURL(a.StoredName),
+				"is_image": a.IsImage(),
+			})
+		}
+		c.JSON(http.StatusOK, gin.H{"attachments": out})
+	}
+}
+
+// ---------------- Binding (plan A) ----------------
+
+// BindPendingAttachments attaches attachments uploaded during article creation
+// (owned by session_token, article_id=0) to a newly created article. Called by
+// ArticleCreate after the article row is saved.
+func BindPendingAttachments(db *gorm.DB, token string, articleID uint) error {
+	if token == "" {
+		return nil
+	}
+	return db.Model(&models.Attachment{}).
+		Where("session_token = ? AND article_id = 0", token).
+		Updates(map[string]interface{}{"article_id": articleID, "session_token": ""}).Error
+}
+
+// ---------------- helpers ----------------
+
+// parseUintForm parses a uint form field, tolerating empty/invalid input.
+func parseUintForm(c *gin.Context, field string) uint {
+	v := strings.TrimSpace(c.PostForm(field))
+	if v == "" {
+		return 0
+	}
+	var n uint
+	_, _ = fmt.Sscanf(v, "%d", &n)
+	return n
+}
+
+// parseUintParam parses a uint route param.
+func parseUintParam(c *gin.Context, name string) uint {
+	var n uint
+	_, _ = fmt.Sscanf(c.Param(name), "%d", &n)
+	return n
+}