feat: image variants cache panel

2026-10-08 21:13:32 +02:00
1 parent 951fef18ba
commit d768668014
@@ -0,0 +1,148 @@
+package useCases
+
+import (
+	"RenewCMS/internal/domain/audit"
+	"RenewCMS/internal/domain/image"
+	"context"
+	"time"
+)
+
+type PurgeVariantCacheCommand struct {
+	Scope   image.CachePurgeScope
+	Variant string
+	ImageID uint32
+}
+
+type VariantCachePurgeResult struct {
+	Scope  image.CachePurgeScope
+	Files  int
+	Bytes  int64
+	Failed int
+}
+
+type PurgeVariantCacheUseCase struct {
+	variants image.VariantRepository
+	images   image.Repository
+	cache    image.VariantCacheRepository
+	files    variantCache
+	recorder audit.Recorder
+	now      func() time.Time
+}
+
+func NewPurgeVariantCacheUseCase(variants image.VariantRepository, images image.Repository, cache image.VariantCacheRepository, files image.VariantFileRepository, storage image.Storage, now func() time.Time, recorder audit.Recorder) *PurgeVariantCacheUseCase {
+	return &PurgeVariantCacheUseCase{variants, images, cache, variantCache{files, storage}, recorder, now}
+}
+
+type cachePurgePlan struct {
+	filter image.VariantFileFilter
+	event  audit.Event
+}
+
+func (u *PurgeVariantCacheUseCase) Purge(ctx context.Context, command PurgeVariantCacheCommand) (VariantCachePurgeResult, error) {
+	plan, err := u.plan(command)
+	if err != nil {
+		return VariantCachePurgeResult{}, err
+	}
+	result, err := u.purgeMatching(plan.filter)
+	result.Scope = command.Scope
+	if err != nil {
+		recordFailure(ctx, u.recorder, plan.event, err)
+		return result, err
+	}
+	u.record(ctx, plan.event, result)
+	return result, nil
+}
+
+func (u *PurgeVariantCacheUseCase) plan(command PurgeVariantCacheCommand) (cachePurgePlan, error) {
+	switch command.Scope {
+	case image.CacheScopeAll:
+		return cachePurgePlan{event: audit.NewEvent(audit.ActionVariantPurgeAll, audit.CategoryMedia)}, nil
+	case image.CacheScopeUnused:
+		return u.unusedPlan()
+	case image.CacheScopeVariant:
+		return u.variantPlan(command.Variant)
+	case image.CacheScopeImage:
+		return u.imagePlan(command.ImageID)
+	default:
+		return cachePurgePlan{}, image.ErrCachePurgeScope
+	}
+}
+
+func (u *PurgeVariantCacheUseCase) unusedPlan() (cachePurgePlan, error) {
+	variants, err := u.variants.List()
+	if err != nil {
+		return cachePurgePlan{}, err
+	}
+	event := audit.NewEvent(audit.ActionVariantPurgeUnused, audit.CategoryMedia)
+	filter := image.VariantFileFilter{Unused: &image.UnusedFilter{VariantNames: enabledNames(variants), Cutoff: image.UnusedCutoff(u.now())}}
+	return cachePurgePlan{filter: filter, event: event}, nil
+}
+
+func (u *PurgeVariantCacheUseCase) variantPlan(name string) (cachePurgePlan, error) {
+	variant, err := u.variants.Get(name)
+	if err != nil {
+		return cachePurgePlan{}, err
+	}
+	if variant.Name != name {
+		return cachePurgePlan{}, image.ErrVariantNotFound
+	}
+	event := audit.NewEvent(audit.ActionVariantPurge, audit.CategoryMedia)
+	event.Target = audit.VariantTarget(name)
+	return cachePurgePlan{filter: image.VariantFileFilter{VariantName: name}, event: event}, nil
+}
+
+func (u *PurgeVariantCacheUseCase) imagePlan(id uint32) (cachePurgePlan, error) {
+	img, err := u.images.Get(id)
+	if err != nil {
+		return cachePurgePlan{}, err
+	}
+	event := audit.NewEvent(audit.ActionVariantPurgeImage, audit.CategoryMedia)
+	event.Target = imageTarget(img)
+	return cachePurgePlan{filter: image.VariantFileFilter{SourceName: image.StoredName(img.Path)}, event: event}, nil
+}
+
+func (u *PurgeVariantCacheUseCase) purgeMatching(filter image.VariantFileFilter) (VariantCachePurgeResult, error) {
+	var result VariantCachePurgeResult
+	var after uint32
+	for {
+		rows, err := u.cache.ListPage(filter, after, image.CachePurgeBatchSize)
+		if err != nil {
+			return result, err
+		}
+		for _, row := range rows {
+			after = row.ID
+			if err := u.files.purgeRow(row); err != nil {
+				result.Failed++
+				continue
+			}
+			result.Files++
+			result.Bytes += row.Size
+		}
+		if len(rows) < image.CachePurgeBatchSize {
+			return result, nil
+		}
+	}
+}
+
+func (u *PurgeVariantCacheUseCase) record(ctx context.Context, event audit.Event, result VariantCachePurgeResult) {
+	if result.Files == 0 && result.Failed == 0 {
+		return
+	}
+	event.Params = cachePurgeParams(event.Action, result)
+	if result.Files == 0 {
+		failFrom(ctx, u.recorder, event, GenericFailureReason)
+		return
+	}
+	u.recorder.Record(ctx, event)
+}
+
+func cachePurgeParams(action string, result VariantCachePurgeResult) map[string]any {
+	params := map[string]any{audit.ParamPurgedFiles: result.Files, audit.ParamPurgedBytes: result.Bytes}
+	if action == audit.ActionVariantPurgeUnused {
+		params[audit.ParamOlderThanDays] = image.UnusedVariantDays
+	}
+	if result.Failed > 0 {
+		params[audit.ParamFailedFiles] = result.Failed
+	}
+	return params
+}