148 lines
3.9 KiB
Go
148 lines
3.9 KiB
Go
package useCases
|
|
|
|
import (
|
|
"RenewCMS/internal/domain/article"
|
|
"RenewCMS/internal/domain/image"
|
|
"cmp"
|
|
"errors"
|
|
"slices"
|
|
"strings"
|
|
)
|
|
|
|
type MergeMediaResult struct {
|
|
ArticlesUpdated int
|
|
Merged int
|
|
UpdatedArticleIDs []uint32
|
|
}
|
|
|
|
type MergeMediaUseCase struct {
|
|
imageRepository image.Repository
|
|
articleRepository article.Repository
|
|
remover mediaRemover
|
|
}
|
|
|
|
func NewMergeMediaUseCase(imageRepository image.Repository, articleRepository article.Repository, storage image.Storage) *MergeMediaUseCase {
|
|
return &MergeMediaUseCase{imageRepository, articleRepository, mediaRemover{imageRepository, storage}}
|
|
}
|
|
|
|
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.remover.remove(duplicate); err != nil {
|
|
return MergeMediaResult{}, err
|
|
}
|
|
}
|
|
|
|
return MergeMediaResult{ArticlesUpdated: len(rewrites), Merged: len(copies), UpdatedArticleIDs: rewrittenIds(rewrites)}, nil
|
|
}
|
|
|
|
func rewrittenIds(rewrites []bodyRewrite) []uint32 {
|
|
ids := make([]uint32, 0, len(rewrites))
|
|
for _, plan := range rewrites {
|
|
ids = append(ids, plan.articleId)
|
|
}
|
|
return ids
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|