feat(API): media library

internal/infrastructure/useCases/CreateImage.go

@@ -2,8 +2,26 @@ package useCases
 
 import (
 	"RenewCMS/internal/domain/image"
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/xml"
+	stdimage "image"
+	"io"
+
+	_ "golang.org/x/image/webp"
+	_ "image/jpeg"
+	_ "image/png"
 )
 
+const svgRootElement = "svg"
+
+var rasterFormats = map[string]string{
+	"image/png":  "png",
+	"image/jpeg": "jpeg",
+	"image/webp": "webp",
+}
+
 type CreateImageUseCase struct {
 	imageRepository image.Repository
 }
@@ -16,8 +34,68 @@ func (g *CreateImageUseCase) CreateImage(input image.ImageInput) (image.Image, e
 	if !image.IsAllowedContentType(input.ContentType) {
 		return image.Image{}, image.ErrImageTypeNotAllowed
 	}
-	if input.Size > image.MaxImageSize {
-		return image.Image{}, image.ErrImageTooLarge
+
+	data, err := readWithinLimit(input.Content)
+	if err != nil {
+		return image.Image{}, err
+	}
+
+	width, height, err := measure(data, input.ContentType)
+	if err != nil {
+		return image.Image{}, err
+	}
+
+	checksum := sha256.Sum256(data)
+	return g.imageRepository.Create(image.ImageInput{
+		Content:      bytes.NewReader(data),
+		Filename:     image.NormalizeUploadFilename(input.Filename, input.ContentType),
+		Size:         int64(len(data)),
+		ContentType:  input.ContentType,
+		Width:        width,
+		Height:       height,
+		SHA256:       hex.EncodeToString(checksum[:]),
+		UploadedByID: input.UploadedByID,
+	})
+}
+
+func readWithinLimit(content io.Reader) ([]byte, error) {
+	if content == nil {
+		return nil, image.ErrImageUnreadable
+	}
+	data, err := io.ReadAll(io.LimitReader(content, image.MaxImageSize+1))
+	if err != nil {
+		return nil, err
+	}
+	if int64(len(data)) > image.MaxImageSize {
+		return nil, image.ErrImageTooLarge
+	}
+	return data, nil
+}
+
+func measure(data []byte, contentType string) (int, int, error) {
+	if contentType == "image/svg+xml" {
+		if !hasSvgRoot(data) {
+			return 0, 0, image.ErrImageUnreadable
+		}
+		return 0, 0, nil
+	}
+
+	config, format, err := stdimage.DecodeConfig(bytes.NewReader(data))
+	if err != nil || format != rasterFormats[contentType] {
+		return 0, 0, image.ErrImageUnreadable
+	}
+	return config.Width, config.Height, nil
+}
+
+func hasSvgRoot(data []byte) bool {
+	decoder := xml.NewDecoder(bytes.NewReader(data))
+	for {
+		token, err := decoder.Token()
+		if err != nil {
+			return false
+		}
+		if start, ok := token.(xml.StartElement); ok {
+			return start.Name.Local == svgRootElement
+		}
 	}
-	return g.imageRepository.Create(input)
 }

internal/infrastructure/useCases/DeleteArticle.go

@@ -1,30 +1,15 @@
 package useCases
 
-import (
-	"RenewCMS/internal/domain/article"
-	"RenewCMS/internal/domain/image"
-)
+import "RenewCMS/internal/domain/article"
 
 type DeleteArticleUseCase struct {
 	articleRepository article.Repository
-	imageRepository   image.Repository
 }
 
-func NewDeleteArticleUseCase(articleRepository article.Repository, imageRepository image.Repository) *DeleteArticleUseCase {
-	return &DeleteArticleUseCase{articleRepository, imageRepository}
+func NewDeleteArticleUseCase(articleRepository article.Repository) *DeleteArticleUseCase {
+	return &DeleteArticleUseCase{articleRepository}
 }
 
 func (g *DeleteArticleUseCase) DeleteArticle(id uint32) error {
-	a, err := g.articleRepository.Get(id)
-	if err != nil {
-		return err
-	}
-
-	for _, img := range a.Images {
-		if err := g.imageRepository.Delete(img.ID); err != nil {
-			return err
-		}
-	}
-
 	return g.articleRepository.Delete(id)
 }

internal/infrastructure/useCases/DeleteImage.go

@@ -1,15 +0,0 @@
-package useCases
-
-import "RenewCMS/internal/domain/image"
-
-type DeleteImageUseCase struct {
-	imageRepository image.Repository
-}
-
-func NewDeleteImageUseCase(imageRepository image.Repository) *DeleteImageUseCase {
-	return &DeleteImageUseCase{imageRepository}
-}
-
-func (g *DeleteImageUseCase) DeleteImage(imageId uint32) error {
-	return g.imageRepository.Delete(imageId)
-}

internal/infrastructure/useCases/DeleteMedia.go

@@ -0,0 +1,15 @@
+package useCases
+
+import "RenewCMS/internal/domain/image"
+
+type DeleteMediaUseCase struct {
+	imageRepository image.Repository
+}
+
+func NewDeleteMediaUseCase(imageRepository image.Repository) *DeleteMediaUseCase {
+	return &DeleteMediaUseCase{imageRepository}
+}
+
+func (u *DeleteMediaUseCase) Delete(id uint32) error {
+	return u.imageRepository.Delete(id)
+}

internal/infrastructure/useCases/GetMediaUsage.go

@@ -0,0 +1,23 @@
+package useCases
+
+import (
+	"RenewCMS/internal/domain/article"
+	"RenewCMS/internal/domain/image"
+)
+
+type GetMediaUsageUseCase struct {
+	imageRepository   image.Repository
+	articleRepository article.Repository
+}
+
+func NewGetMediaUsageUseCase(imageRepository image.Repository, articleRepository article.Repository) *GetMediaUsageUseCase {
+	return &GetMediaUsageUseCase{imageRepository, articleRepository}
+}
+
+func (u *GetMediaUsageUseCase) Usage(id uint32) ([]article.Article, error) {
+	img, err := u.imageRepository.Get(id)
+	if err != nil {
+		return nil, err
+	}
+	return u.articleRepository.FindByBodyContaining(image.StoredName(img.Path))
+}

internal/infrastructure/useCases/ListMedia.go

@@ -0,0 +1,199 @@
+package useCases
+
+import (
+	"RenewCMS/internal/domain/article"
+	"RenewCMS/internal/domain/image"
+	"RenewCMS/internal/domain/user"
+	"encoding/base64"
+	"strconv"
+	"strings"
+)
+
+const cursorPrefix = "offset:"
+
+type MediaItem struct {
+	Image      image.Image
+	UploadedBy string
+	UsedIn     int
+	Duplicate  bool
+}
+
+type MediaCounts struct {
+	All        int
+	Unused     int
+	Duplicates int
+}
+
+type MediaPage struct {
+	Items      []MediaItem
+	NextCursor string
+	Counts     MediaCounts
+}
+
+type ListMediaUseCase struct {
+	imageRepository   image.Repository
+	articleRepository article.Repository
+	userRepository    user.Repository
+}
+
+func NewListMediaUseCase(imageRepository image.Repository, articleRepository article.Repository, userRepository user.Repository) *ListMediaUseCase {
+	return &ListMediaUseCase{imageRepository, articleRepository, userRepository}
+}
+
+func (l *ListMediaUseCase) List(query image.ListQuery) (MediaPage, error) {
+	if err := query.Validate(); err != nil {
+		return MediaPage{}, err
+	}
+	offset, err := decodeCursor(query.Cursor)
+	if err != nil {
+		return MediaPage{}, err
+	}
+
+	usage, err := l.usageCounter()
+	if err != nil {
+		return MediaPage{}, err
+	}
+	duplicateHashes, err := l.duplicateHashes()
+	if err != nil {
+		return MediaPage{}, err
+	}
+	counts, err := l.counts(usage)
+	if err != nil {
+		return MediaPage{}, err
+	}
+
+	images, err := l.imageRepository.List(image.SearchQuery{Search: strings.TrimSpace(query.Search), Hash: query.Hash})
+	if err != nil {
+		return MediaPage{}, err
+	}
+	image.SortImages(images, query.Sort)
+
+	matching := make([]image.Image, 0, len(images))
+	for _, img := range images {
+		if matchesFilter(query.Filter, usage(img), duplicateHashes[img.SHA256] && img.SHA256 != "") {
+			matching = append(matching, img)
+		}
+	}
+
+	pageEnd := min(offset+query.Limit, len(matching))
+	pageStart := min(offset, pageEnd)
+	names := newUploaderNames(l.userRepository)
+	items := []MediaItem{}
+	for _, img := range matching[pageStart:pageEnd] {
+		uploadedBy, err := names.nameOf(img.UploadedByID)
+		if err != nil {
+			return MediaPage{}, err
+		}
+		items = append(items, MediaItem{
+			Image:      img,
+			UploadedBy: uploadedBy,
+			UsedIn:     usage(img),
+			Duplicate:  img.SHA256 != "" && duplicateHashes[img.SHA256],
+		})
+	}
+
+	page := MediaPage{Items: items, Counts: counts}
+	if pageEnd < len(matching) {
+		page.NextCursor = encodeCursor(pageEnd)
+	}
+	return page, nil
+}
+
+func (l *ListMediaUseCase) Describe(img image.Image) (MediaItem, error) {
+	articles, err := l.articleRepository.FindByBodyContaining(image.StoredName(img.Path))
+	if err != nil {
+		return MediaItem{}, err
+	}
+	uploadedBy, err := newUploaderNames(l.userRepository).nameOf(img.UploadedByID)
+	if err != nil {
+		return MediaItem{}, err
+	}
+
+	duplicate := false
+	if img.SHA256 != "" {
+		sameContent, err := l.imageRepository.FindByHash(img.SHA256)
+		if err != nil {
+			return MediaItem{}, err
+		}
+		duplicate = len(sameContent) > 1
+	}
+
+	return MediaItem{Image: img, UploadedBy: uploadedBy, UsedIn: len(articles), Duplicate: duplicate}, nil
+}
+
+func (l *ListMediaUseCase) usageCounter() (func(image.Image) int, error) {
+	articles, err := l.articleRepository.FindByFilters(article.Filters{})
+	if err != nil {
+		return nil, err
+	}
+	return func(img image.Image) int {
+		storedName := image.StoredName(img.Path)
+		used := 0
+		for _, a := range articles {
+			if strings.Contains(a.Body, storedName) {
+				used++
+			}
+		}
+		return used
+	}, nil
+}
+
+func (l *ListMediaUseCase) duplicateHashes() (map[string]bool, error) {
+	duplicates, err := l.imageRepository.ListDuplicates()
+	if err != nil {
+		return nil, err
+	}
+	hashes := make(map[string]bool, len(duplicates))
+	for _, img := range duplicates {
+		hashes[img.SHA256] = true
+	}
+	return hashes, nil
+}
+
+func (l *ListMediaUseCase) counts(usage func(image.Image) int) (MediaCounts, error) {
+	libraryCounts, err := l.imageRepository.Counts()
+	if err != nil {
+		return MediaCounts{}, err
+	}
+	everything, err := l.imageRepository.List(image.SearchQuery{})
+	if err != nil {
+		return MediaCounts{}, err
+	}
+	unused := 0
+	for _, img := range everything {
+		if usage(img) == 0 {
+			unused++
+		}
+	}
+	return MediaCounts{All: libraryCounts.All, Unused: unused, Duplicates: libraryCounts.DuplicateGroups}, nil
+}
+
+func matchesFilter(filter image.Filter, usedIn int, duplicate bool) bool {
+	switch filter {
+	case image.FilterUnused:
+		return usedIn == 0
+	case image.FilterDuplicates:
+		return duplicate
+	default:
+		return true
+	}
+}
+
+func encodeCursor(offset int) string {
+	return base64.RawURLEncoding.EncodeToString([]byte(cursorPrefix + strconv.Itoa(offset)))
+}
+
+func decodeCursor(cursor string) (int, error) {
+	if cursor == "" {
+		return 0, nil
+	}
+	raw, err := base64.RawURLEncoding.DecodeString(cursor)
+	if err != nil || !strings.HasPrefix(string(raw), cursorPrefix) {
+		return 0, image.ErrInvalidQuery
+	}
+	offset, err := strconv.Atoi(strings.TrimPrefix(string(raw), cursorPrefix))
+	if err != nil || offset < 0 {
+		return 0, image.ErrInvalidQuery
+	}
+	return offset, nil
+}

internal/infrastructure/useCases/MergeMedia.go

@@ -0,0 +1,137 @@
+package useCases
+
+import (
+	"RenewCMS/internal/domain/article"
+	"RenewCMS/internal/domain/image"
+	"cmp"
+	"errors"
+	"slices"
+	"strings"
+)
+
+type MergeMediaResult struct {
+	ArticlesUpdated int
+	Merged          int
+}
+
+type MergeMediaUseCase struct {
+	imageRepository   image.Repository
+	articleRepository article.Repository
+}
+
+func NewMergeMediaUseCase(imageRepository image.Repository, articleRepository article.Repository) *MergeMediaUseCase {
+	return &MergeMediaUseCase{imageRepository, articleRepository}
+}
+
+type bodyRewrite struct {
+	articleId uint32
+	original  string
+	rewritten string
+}
+
+func (u *MergeMediaUseCase) Merge(keepId uint32, mergeIds []uint32) (MergeMediaResult, error) {
+	if err := validateMergeRequest(keepId, mergeIds); err != nil {
+		return MergeMediaResult{}, err
+	}
+
+	kept, err := u.imageRepository.Get(keepId)
+	if err != nil {
+		return MergeMediaResult{}, err
+	}
+	copies, err := u.loadCopies(kept, mergeIds)
+	if err != nil {
+		return MergeMediaResult{}, err
+	}
+
+	rewrites, err := u.planRewrites(kept, copies)
+	if err != nil {
+		return MergeMediaResult{}, err
+	}
+	if err := u.applyRewrites(rewrites); err != nil {
+		return MergeMediaResult{}, err
+	}
+
+	for _, duplicate := range copies {
+		if err := u.imageRepository.Delete(duplicate.ID); err != nil {
+			return MergeMediaResult{}, err
+		}
+	}
+
+	return MergeMediaResult{ArticlesUpdated: len(rewrites), Merged: len(copies)}, nil
+}
+
+func validateMergeRequest(keepId uint32, mergeIds []uint32) error {
+	if keepId == 0 || len(mergeIds) == 0 {
+		return image.ErrInvalidMergeRequest
+	}
+	seen := map[uint32]bool{keepId: true}
+	for _, id := range mergeIds {
+		if id == 0 || seen[id] {
+			return image.ErrInvalidMergeRequest
+		}
+		seen[id] = true
+	}
+	return nil
+}
+
+func (u *MergeMediaUseCase) loadCopies(kept image.Image, mergeIds []uint32) ([]image.Image, error) {
+	copies := make([]image.Image, 0, len(mergeIds))
+	for _, id := range mergeIds {
+		duplicate, err := u.imageRepository.Get(id)
+		if errors.Is(err, image.ErrImageNotFound) {
+			return nil, image.ErrMergeCopyMissing
+		}
+		if err != nil {
+			return nil, err
+		}
+		if duplicate.SHA256 == "" || duplicate.SHA256 != kept.SHA256 {
+			return nil, image.ErrMergeHashMismatch
+		}
+		copies = append(copies, duplicate)
+	}
+	return copies, nil
+}
+
+func (u *MergeMediaUseCase) planRewrites(kept image.Image, copies []image.Image) ([]bodyRewrite, error) {
+	keptName := image.StoredName(kept.Path)
+	rewritten := map[uint32]*bodyRewrite{}
+
+	for _, duplicate := range copies {
+		copyName := image.StoredName(duplicate.Path)
+		articles, err := u.articleRepository.FindByBodyContaining(copyName)
+		if err != nil {
+			return nil, err
+		}
+		for _, a := range articles {
+			plan, ok := rewritten[a.ID]
+			if !ok {
+				plan = &bodyRewrite{articleId: a.ID, original: a.Body, rewritten: a.Body}
+				rewritten[a.ID] = plan
+			}
+			plan.rewritten = strings.ReplaceAll(plan.rewritten, copyName, keptName)
+		}
+	}
+
+	plans := make([]bodyRewrite, 0, len(rewritten))
+	for _, plan := range rewritten {
+		plans = append(plans, *plan)
+	}
+	slices.SortFunc(plans, func(a, b bodyRewrite) int { return cmp.Compare(a.articleId, b.articleId) })
+	return plans, nil
+}
+
+func (u *MergeMediaUseCase) applyRewrites(rewrites []bodyRewrite) error {
+	for applied, plan := range rewrites {
+		if _, err := u.articleRepository.UpdateBody(plan.articleId, plan.rewritten); err != nil {
+			u.restoreBodies(rewrites[:applied])
+			return err
+		}
+	}
+	return nil
+}
+
+func (u *MergeMediaUseCase) restoreBodies(applied []bodyRewrite) {
+	for _, plan := range applied {
+		_, _ = u.articleRepository.UpdateBody(plan.articleId, plan.original)
+	}
+}

internal/infrastructure/useCases/RenameMedia.go

@@ -0,0 +1,25 @@
+package useCases
+
+import "RenewCMS/internal/domain/image"
+
+type RenameMediaUseCase struct {
+	imageRepository image.Repository
+}
+
+func NewRenameMediaUseCase(imageRepository image.Repository) *RenameMediaUseCase {
+	return &RenameMediaUseCase{imageRepository}
+}
+
+func (u *RenameMediaUseCase) Rename(id uint32, stem string) (image.Image, error) {
+	validStem, err := image.ValidateFilenameStem(stem)
+	if err != nil {
+		return image.Image{}, err
+	}
+
+	current, err := u.imageRepository.Get(id)
+	if err != nil {
+		return image.Image{}, err
+	}
+
+	return u.imageRepository.Rename(id, validStem+image.ExtensionOf(current.Filename))
+}

internal/infrastructure/useCases/UpdateArticle.go

@@ -14,10 +14,6 @@ func (g *UpdateArticleUseCase) UpdateBody(id uint32, body string) (article.Artic
 	return g.articleRepository.UpdateBody(id, body)
 }
 
-func (g *UpdateArticleUseCase) AddImage(articleId uint32, imageId uint32) error {
-	return g.articleRepository.AddImage(articleId, imageId)
-}
-
 func (g *UpdateArticleUseCase) UpdateIsOnline(id uint32, isOnline bool) (article.Article, error) {
 	return g.articleRepository.UpdateIsOnline(id, isOnline)
 }

internal/infrastructure/useCases/mediaUploader.go

@@ -0,0 +1,40 @@
+package useCases
+
+import (
+	"RenewCMS/internal/domain/user"
+	"errors"
+)
+
+type uploaderNames struct {
+	userRepository user.Repository
+	names          map[uint32]string
+}
+
+func newUploaderNames(userRepository user.Repository) *uploaderNames {
+	return &uploaderNames{userRepository: userRepository, names: map[uint32]string{}}
+}
+
+func (u *uploaderNames) nameOf(userId uint32) (string, error) {
+	if userId == 0 {
+		return "", nil
+	}
+	if name, ok := u.names[userId]; ok {
+		return name, nil
+	}
+
+	uploader, err := u.userRepository.Get(userId)
+	if errors.Is(err, user.ErrUserNotFound) {
+		u.names[userId] = ""
+		return "", nil
+	}
+	if err != nil {
+		return "", err
+	}
+
+	name := uploader.DisplayName
+	if name == "" {
+		name = uploader.Username
+	}
+	u.names[userId] = name
+	return name, nil
+}