package content import ( "context" "database/sql" "encoding/json" "errors" "fmt" "sort" "time" "mediarr/database" "mediarr/document" "mediarr/ident" "mediarr/permission" ) const dayMillis int64 = 24 * 60 * 60 * 1000 type RetentionResult struct { Purged []ident.UUID Kept int } type retentionPolicy struct { KeepAllDays int `json:"keep_all_days"` KeepDailyDays int `json:"keep_daily_days"` KeepMonthly int `json:"keep_monthly"` } func (p retentionPolicy) validate() error { if p.KeepAllDays < 0 || p.KeepDailyDays < 0 || p.KeepMonthly < 0 { return ErrInvalidRetention } return nil } func (s *Service) ApplyRetention(ctx context.Context, actorID, documentID ident.UUID) (RetentionResult, error) { documentRow, err := s.getDocument(ctx, documentID) if err != nil { return RetentionResult{}, err } if documentRow.DeletedAt.Valid { return RetentionResult{}, fmt.Errorf("%w: %s", document.ErrDocumentDeleted, documentID) } if err := s.can(ctx, actorID, documentID, permission.Manage); err != nil { return RetentionResult{}, err } policyBytes, err := s.db.Queries.GetEffectiveDocumentPolicy(ctx, documentID) if err != nil { if errors.Is(err, sql.ErrNoRows) { return RetentionResult{}, fmt.Errorf("%w: %s", ErrNoStoragePolicy, documentID) } return RetentionResult{}, err } policyID, err := ident.FromBytes(policyBytes) if err != nil { return RetentionResult{}, fmt.Errorf("%w: %v", ErrNoStoragePolicy, err) } storagePolicy, err := s.db.Queries.GetStoragePolicy(ctx, policyID) if err != nil { if errors.Is(err, sql.ErrNoRows) { return RetentionResult{}, fmt.Errorf("%w: %s", ErrNoStoragePolicy, policyID) } return RetentionResult{}, err } var retention retentionPolicy if err := json.Unmarshal([]byte(storagePolicy.VersionRetention), &retention); err != nil { return RetentionResult{}, fmt.Errorf("%w: %v", ErrInvalidRetention, err) } if err := retention.validate(); err != nil { return RetentionResult{}, err } versions, err := s.db.Queries.ListDocumentVersions(ctx, documentID) if err != nil { return RetentionResult{}, err } purgeIDs := retentionPurgeIDs(versions, documentRow.HeadVersionID, retention, nowMillis()) result := RetentionResult{ Kept: len(versions) - len(purgeIDs), } for _, versionID := range purgeIDs { purged, err := s.purgeVersion(ctx, versionID) if err != nil { return result, err } if purged { result.Purged = append(result.Purged, versionID) } } return result, nil } func retentionPurgeIDs(versions []database.DocumentVersion, headID *ident.UUID, policy retentionPolicy, now int64) []ident.UUID { ordered := append([]database.DocumentVersion(nil), versions...) sort.Slice(ordered, func(i, j int) bool { if ordered[i].CreatedAt == ordered[j].CreatedAt { return ordered[i].Seq > ordered[j].Seq } return ordered[i].CreatedAt > ordered[j].CreatedAt }) keep := make(map[ident.UUID]bool, len(ordered)) dailyKept := make(map[string]bool) monthlyKept := make(map[string]bool) for _, version := range ordered { if version.ContentPurgedAt.Valid || version.Pinned != 0 || (headID != nil && *headID == version.ID) { keep[version.ID] = true continue } if version.CreatedAt > now { keep[version.ID] = true continue } age := now - version.CreatedAt ageDays := age / dayMillis switch { case policy.KeepAllDays > 0 && ageDays <= int64(policy.KeepAllDays): keep[version.ID] = true case policy.KeepDailyDays > 0 && ageDays <= int64(policy.KeepDailyDays): day := time.UnixMilli(version.CreatedAt).UTC().Format("2006-01-02") if !dailyKept[day] { dailyKept[day] = true keep[version.ID] = true } case policy.KeepMonthly > 0: month := time.UnixMilli(version.CreatedAt).UTC().Format("2006-01") if !monthlyKept[month] && len(monthlyKept) < policy.KeepMonthly { monthlyKept[month] = true keep[version.ID] = true } } } purge := make([]ident.UUID, 0, len(ordered)-len(keep)) for _, version := range ordered { if !keep[version.ID] { purge = append(purge, version.ID) } } return purge }