feat: auto cleanup - ennoblements

cmd/twhelp/internal/job/job.go

@@ -155,6 +155,7 @@ func runJob(c *cli.Context, timeout time.Duration, fn runJobFunc) error {
 	tribeSnapshotSvc := service.NewTribeSnapshot(bundb.NewTribeSnapshot(db), tribeSvc)
 	playerSvc := service.NewPlayer(bundb.NewPlayer(db), tribeChangeSvc, client)
 	playerSnapshotSvc := service.NewPlayerSnapshot(bundb.NewPlayerSnapshot(db), playerSvc)
+	ennoblementSvc := service.NewEnnoblement(bundb.NewEnnoblement(db), client)
 
 	return fn(ctx, service.NewJob(
 		versionSvc,
@@ -162,6 +163,6 @@ func runJob(c *cli.Context, timeout time.Duration, fn runJobFunc) error {
 		msg.NewServerPublisher(publisher, marshaler),
 		msg.NewEnnoblementPublisher(publisher, marshaler),
 		msg.NewSnapshotPublisher(publisher, marshaler),
-		[]service.CleanUper{playerSnapshotSvc, tribeSnapshotSvc},
+		[]service.CleanUper{playerSnapshotSvc, tribeSnapshotSvc, ennoblementSvc},
 	))
 }

internal/bundb/ennoblement.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"errors"
 	"fmt"
+	"time"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/bundb/internal/model"
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
@@ -124,6 +125,19 @@ func (e *Ennoblement) ListCountWithRelations(
 	return result, int64(count), nil
 }
 
+func (e *Ennoblement) Delete(ctx context.Context, serverKey string, createdAtLTE time.Time) error {
+	if _, err := e.db.NewDelete().
+		Model(&model.Ennoblement{}).
+		Where("server_key = ?", serverKey).
+		Where("created_at <= ?", createdAtLTE).
+		Returning("NULL").
+		Exec(ctx); err != nil {
+		return fmt.Errorf("couldn't delete ennoblements: %w", err)
+	}
+
+	return nil
+}
+
 type listEnnoblementsParamsApplier struct {
 	params domain.ListEnnoblementsParams
 }

internal/bundb/ennoblement_test.go

@@ -346,3 +346,21 @@ func TestEnnoblement_List(t *testing.T) {
 		})
 	}
 }
+
+func TestEnnoblement_Delete(t *testing.T) {
+	t.Parallel()
+
+	db := newDB(t)
+	fixture := loadFixtures(t, db)
+	repo := bundb.NewEnnoblement(db)
+
+	ennoblementsBeforeDelete, err := repo.List(context.Background(), domain.ListEnnoblementsParams{})
+	assert.NoError(t, err)
+	assert.Greater(t, len(ennoblementsBeforeDelete), 0)
+
+	assert.NoError(t, repo.Delete(context.Background(), fixture.server(t, "pl169").Key, time.Date(2021, time.September, 30, 23, 0, 0, 0, time.UTC)))
+
+	ennoblementsAfterDelete, err := repo.List(context.Background(), domain.ListEnnoblementsParams{})
+	assert.NoError(t, err)
+	assert.Equal(t, len(ennoblementsBeforeDelete)-1, len(ennoblementsAfterDelete))
+}

internal/service/ennoblement.go

@@ -28,6 +28,7 @@ type EnnoblementRepository interface {
 		ctx context.Context,
 		params domain.ListEnnoblementsParams,
 	) ([]domain.EnnoblementWithRelations, int64, error)
+	Delete(ctx context.Context, serverKey string, createdAtLTE time.Time) error
 }
 
 //counterfeiter:generate -o internal/mock/ennoblement_getter.gen.go . EnnoblementGetter
@@ -146,3 +147,16 @@ func (e *Ennoblement) getLatestEnnoblement(ctx context.Context, key string) (dom
 
 	return ennoblements[0], nil
 }
+
+func (e *Ennoblement) CleanUp(ctx context.Context, srv domain.Server) error {
+	if srv.Special || srv.Open || srv.EnnoblementDataUpdatedAt.After(time.Now().Add(-30*24*time.Hour) /* 30 days */) {
+		return nil
+	}
+
+	// delete ennoblements older than 1 year
+	if err := e.repo.Delete(ctx, srv.Key, time.Now().Add(-365*24*time.Hour)); err != nil {
+		return fmt.Errorf("couldn't delete old ennoblements: %w", err)
+	}
+
+	return nil
+}

internal/service/ennoblement_test.go

@@ -312,3 +312,46 @@ func TestEnnoblement_ListCountWithRelations(t *testing.T) {
 		}
 	})
 }
+
+func TestEnnoblement_CleanUp(t *testing.T) {
+	t.Parallel()
+
+	serverKey := "pl151"
+	repo := &mock.FakeEnnoblementRepository{}
+	client := &mock.FakeEnnoblementGetter{}
+	repo.DeleteReturns(nil)
+
+	svc := service.NewEnnoblement(repo, client)
+
+	assert.NoError(t, svc.CleanUp(context.Background(), domain.Server{
+		Key:                      serverKey,
+		Special:                  true,
+		Open:                     false,
+		EnnoblementDataUpdatedAt: time.Now().Add(-30 * 24 * time.Hour),
+	}))
+	assert.Equal(t, 0, repo.DeleteCallCount()) // only servers with Special = false
+
+	assert.NoError(t, svc.CleanUp(context.Background(), domain.Server{
+		Key:                      serverKey,
+		Open:                     true,
+		EnnoblementDataUpdatedAt: time.Now().Add(-30 * 24 * time.Hour),
+	}))
+	assert.Equal(t, 0, repo.DeleteCallCount()) // only servers with Open = false
+
+	assert.NoError(t, svc.CleanUp(context.Background(), domain.Server{
+		Key:                      serverKey,
+		Open:                     false,
+		EnnoblementDataUpdatedAt: time.Now(),
+	}))
+	assert.Equal(t, 0, repo.DeleteCallCount()) // only servers with EnnoblementDataUpdatedAt < now - 30 days
+
+	assert.NoError(t, svc.CleanUp(context.Background(), domain.Server{
+		Key:                      serverKey,
+		Open:                     false,
+		EnnoblementDataUpdatedAt: time.Now().Add(-30 * 24 * time.Hour),
+	}))
+	require.Equal(t, 1, repo.DeleteCallCount())
+	_, argsServerKey, argsCreatedAtLTE := repo.DeleteArgsForCall(0)
+	assert.Equal(t, serverKey, argsServerKey)
+	assert.WithinDuration(t, time.Now().Add(-365*24*time.Hour), argsCreatedAtLTE, time.Second)
+}